home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / stut_src / text.c < prev    next >
Text File  |  1996-05-27  |  91KB  |  3,543 lines
  1. /*
  2.  * textes.c
  3.  *
  4.  * Purpose:
  5.  * --------
  6.  * Manipulation de textes
  7.  *
  8.  * History:
  9.  * --------
  10.  * 1993: fplanque: Created
  11.  */
  12.  
  13.      #include "!OPTIONS.H"                /* Options de compilation */         
  14.     #define    THIS_FILE    "TEXT.C v1.10 - 07.95"
  15.  
  16. /*
  17.  * System headers:
  18.  */
  19.     #include    <stdio.h>                    /* header standard */
  20.     #include    <stdlib.h>                    /* header librairie de fnct std */
  21.     #include <string.h>                    /* header tt de chaines */
  22.     #include    <aes.h>                        /* header AES */
  23.     #include    <vdi.h>                        /* VDI */
  24.    
  25.  
  26. /*
  27.  * Custom headers:
  28.  */
  29.     #include "SPEC_PU.H"
  30.     #include "S_MALLOC.H"
  31.     #include    "STUT_ONE.RSC\STUT_3.H"                        /* Cnstes fichier RSC */
  32.     #include "AESDEF.H"
  33.     #include "EXFRM_PU.H"
  34.     #include "STKEYMAP.H"    
  35.     #include    "MAIN_PU.H"
  36.     #include "MMENU_PU.H"    
  37.     #include    "TEXT_PU.H"
  38.     #include    "DEBUG_PU.H"    
  39.     #include    "OBJCT_PU.H"    
  40.     #include "FILES_PU.H"
  41.     #include "WIN_PU.H"
  42.     #include "WINDR_PU.H"
  43.     #include "OBJCT_PU.H"
  44.     #include "RTERR_PU.H"
  45.     #include "DATPG_PU.H"
  46.     #include    "VDI_PU.H"    
  47.  
  48. /*
  49.  * ------------------------ PROTOTYPES -------------------------
  50.  */
  51.  
  52. /*
  53.  * PRIVate INTernal prototypes:
  54.  */
  55.     /* -- edition -- */
  56.     static    void    winEdit_MoveCsr(
  57.                             WIPARAMS *    pWiParams,    
  58.                             int            n_YMove,
  59.                             int            n_XMove );
  60.     static    void    winEdit_TypeCar(
  61.                             WIPARAMS *    pWiParams,    
  62.                             char            c_car );
  63.     static    void    winEdit_DelCar(
  64.                             WIPARAMS *    pWiParams,
  65.                             int            b_backspace );    /* In: True si backspace */
  66.     static    void    winEdit_BreakLine(
  67.                             WIPARAMS *    pWiParams );
  68.  
  69.  
  70. /*
  71.  * ------------------------ VARIABLES -------------------------
  72.  */
  73.  
  74.  
  75. /*
  76.  * Public variables: 
  77.  */
  78.     int    G_def_text_width    =    DEF_TEXT_WIDTH;    /* Largeur par d‚faut d'une ligne texte en caractŠres */
  79.  
  80.  
  81.     
  82. /*
  83.  * Private variables: 
  84.  */
  85.     /*
  86.      * Ptr sur boite de r‚glage Params Texte
  87.      */
  88.     OBJECT    *    M_pObj_FormParamsAffText;    
  89.      
  90.  
  91. /*
  92.  * ------------------------ FUNCTIONS -------------------------
  93.  */
  94.  
  95. /*
  96.  * init_text(-)
  97.  *
  98.  * Init de ce module
  99.  *
  100.  * 01.12.94: fplanque: Created
  101.  */
  102. void    init_text( void )
  103. {
  104.     TRACE0( "Initializing " THIS_FILE );
  105.  
  106.     if (rsrc_gaddr( R_TREE, AFFICTXT, &M_pObj_FormParamsAffText) == 0)
  107.         erreur_rsrc();
  108.     rsrc_color( M_pObj_FormParamsAffText );        /* Fixe couleurs */
  109.  
  110. }
  111.  
  112.  
  113. /*
  114.  * text_optimal(-)
  115.  *
  116.  * Purpose:
  117.  * --------
  118.  * D‚termine fenˆtre optimale (full) pour un texte
  119.  *
  120.  * History:
  121.  * --------
  122.  * 1993: fplanque: Created
  123.  */
  124. void text_optimal( 
  125.         int wi_ckind, 
  126.         int *border_x, 
  127.         int *border_y, 
  128.         int *border_w, 
  129.         int *border_h)
  130. {
  131.     int    work_x, work_y, work_w, work_h;    /* Coordonn‚es zone de travail */
  132.  
  133.         work_x = G_std_text .cell_w -4;            /* Texte sera align‚ sur col 2 */
  134.         work_y = 50;                                /* Arbitraire */
  135.         work_w = G_def_text_width * G_std_text .cell_w + 8;    /* Largeur max */
  136.                     /* On rajoute +8 car il y a 4 pix … gauche et … droite */
  137.         work_h = 100;                                /* Arbitraire */
  138.  
  139.     /* Calcule les coordonn‚es totales de la fenˆtre: */
  140.         wind_calc( WC_BORDER, wi_ckind, work_x, work_y, work_w, work_h,
  141.                         border_x, border_y, border_w, border_h );
  142.  
  143.     /* Contr“le que ‡a rentre... en largeur */
  144.         if ( (*border_x + *border_w) > G_w_maxi )
  145.             *border_w = G_w_maxi - *border_x;
  146.  
  147.     /* Hauteur max: */
  148.         *border_y = G_y_mini;
  149.         *border_h = G_h_maxi - G_std_text .cell_h;        
  150. }
  151.                      
  152.                      
  153.                        
  154. /*
  155.  * create_textedit_zone(-)
  156.  *
  157.  * Purpose:
  158.  * --------
  159.  * Cr‚ation d'une zone d'‚dition vide
  160.  * limit‚e … une ligne (mais ‡a peut grandir dynamiquement...)
  161.  *
  162.  * Suggest:
  163.  * --------
  164.  * PROVISOIRE: Contient une boŒte d'alerte pouvant bloquer le serveur
  165.  *
  166.  * History:
  167.  * --------
  168.  * 1993: fplanque: Created 
  169.  * 29.04.94: fplanque: changé header texte
  170.  * 25.05.94: utilise nouveau create_TextInfo()
  171.  * 22.08.94: Consid‚rablement simplifi‚, ne cr‚e plus qu'une zone restreinte … UNE seule ligne VIDE!
  172.  */
  173. TEXTINFO    * create_textedit_zone( void )    /* Out: Infos sur zone d'‚dition cr‚e */
  174. {
  175.     TEXTINFO * pTextInfo;
  176.  
  177.     if( (pTextInfo = create_TextInfo()) == NULL )
  178.     {
  179.         return    NULL;             /* ProblŠme */
  180.     }
  181.     
  182.     /*
  183.      * Ajoute la ligne vide au buffer texte: 
  184.      * Ce sera la premiŠre ligne du texte, elle portera le curseur
  185.      */
  186.     insert_line( pTextInfo -> firstline, NULL, NIL_1, pTextInfo );
  187.  
  188.     return    pTextInfo;
  189.  
  190. }
  191.  
  192.  
  193.  
  194. /*
  195.  * access_text(-)
  196.  *
  197.  * Purpose:
  198.  * --------
  199.  * Acc‚der … un texte en m‚moire (ds groupe TEXTES)
  200.  * pour l'afficher
  201.  *
  202.  * History:
  203.  * --------
  204.  * 1993: fplanque: Created
  205.  * 25.05.94: fplanque: utilise le nouveau create_TextInfo()
  206.  * 06.08.94: extraction du code de controle du nbre de fenˆtre ouverte sur DATAPAGE (limite: 1)
  207.  */
  208. int    access_text( 
  209.             DATAPAGE      *        datapage, 
  210.             WORK_CONTENT *        content_ptr, 
  211.             TEXT_DRAWPAR * *    ppTextDrawPar_retour )        /* Out: */
  212. {
  213.     DATABLOCK *    pDataBlock = datapage -> data.dataBlock;
  214.     /*
  215.      * Adresse des infos sur le nouveau texte 
  216.      * Cr‚e le header du texte en mem: 
  217.      */
  218.     TEXTINFO         *    pTextInfo = create_TextInfo();
  219.     TEXT_DRAWPAR * pTextDrawPar = create_TextDrawPar( pTextInfo, 10 /* bidon */ );
  220.     
  221.     /*
  222.      * Fixe adr de la page courante! (qui contient celle du texte:) 
  223.      */
  224.     content_ptr -> datapage = datapage;
  225.  
  226.     if( pTextInfo == NULL )
  227.     {
  228.         return    0;        /* Ouverture Impossible */
  229.     }
  230.  
  231.     if( pTextDrawPar == NULL )
  232.     {
  233.         free_formatext( pTextInfo );
  234.     }
  235.  
  236.     /*
  237.      * Formatte le texte (BLOC->lignes) pour son affichage: 
  238.      */
  239.     format_text( pTextInfo, pTextInfo -> lastline,
  240.                      pDataBlock -> p_block, pDataBlock -> ul_length, 
  241.                      FMTMODE_NEARBINARY, G_def_text_width ); 
  242.  
  243.     /*
  244.      * Sauve adr des infos sur le texte: 
  245.      */
  246.     pTextDrawPar -> pTextInfo = pTextInfo;
  247.     *ppTextDrawPar_retour = pTextDrawPar;
  248.  
  249.     return    1;
  250. }
  251.  
  252.  
  253.  
  254. /*
  255.  * text_addLineToEnd(-)
  256.  *
  257.  * Purpose:
  258.  * --------
  259.  * Ajoute une ligne … la fin d'un texte
  260.  *
  261.  * History:
  262.  * --------
  263.  * 25.09.94: fplanque: Created
  264.  */
  265. void    text_addLineToEnd(
  266.             TEXTINFO        *    pTextInfo,    /* In: Texte concern‚ */
  267.             const char    *    cpsz_Text )    /* In: Ligne … dupliker et ins‚rer */
  268. {
  269.     /*
  270.      * Adr derniŠre ligne: 
  271.      */
  272.     TEXTLINE    *last_line = pTextInfo -> lastline;
  273.  
  274.     /*
  275.      * Ajoute une ligne: 
  276.      */
  277.     char    *    texte = NULL;
  278.     
  279.     if( cpsz_Text != NULL )
  280.     {
  281.         texte    = STRDUP( cpsz_Text );
  282.     }
  283.  
  284.     insert_line( last_line, texte, NIL, pTextInfo );
  285.     
  286. }
  287.  
  288.  
  289. /*
  290.  * insert_line(-)
  291.  *
  292.  * Purpose:
  293.  * --------
  294.  * Insertion d'une ligne dans un texte quelquonque
  295.  *
  296.  * History:
  297.  * --------
  298.  *     1993: fplanque: Created
  299.  * 28.08.94: fplanque: force bufsize … 0 si l'argument p_TextBuf==NULL
  300.  */
  301. TEXTLINE    * insert_line( 
  302.                 TEXTLINE    *    prev_line,        /* In: after this one */  
  303.                 char         *    p_TextBuf,        /* In: texte de la ligne … ins‚rer */             
  304.                 int             bufsize,            /* In: Taille buffer point‚ par texte: mettre NIL si on veut la taille exacte */ 
  305.                 TEXTINFO *    info_ptr )
  306. {
  307.     TEXTLINE    *    ligne;                                    /* Ligne de texte complŠte */
  308.     TEXTLINE    *    next_line = prev_line -> next;    /* Ligne suivante */
  309.  
  310.     /*
  311.      * Cr‚ation d'une ligne en m‚moire: 
  312.      */    
  313.     ligne = (TEXTLINE *)    MALLOC( sizeof( TEXTLINE ) );
  314.     ligne -> prev = prev_line;            /* Pointeur sur ligne pr‚c‚dente */
  315.     ligne -> next = next_line;            /* Pointeur sur ligne suivante */
  316.  
  317.     ligne -> text = p_TextBuf;                /* Pointeur sur le texte */
  318.  
  319.     if( p_TextBuf != NULL )        /* Si texte il y a... */
  320.     {
  321.         ligne    -> length = (int) strlen( p_TextBuf );
  322.         /*
  323.          * Taille du buffer?: 
  324.          */
  325.         if ( bufsize == NIL )
  326.         {    /*
  327.              * Le buffer fait exactement la taille de la ligne (\0 non compris ) 
  328.              */
  329.             ligne -> info1.bufsize = ligne -> length;    /* Taille du buffer d'‚dition */
  330.         }
  331.         else
  332.         {    /*
  333.              * Le buffer est plus grand: 
  334.              */
  335.             ligne -> info1.bufsize = bufsize;
  336.         }
  337.     }
  338.     else                            /* Sinon: ligne vide: */
  339.     {
  340.         ligne    -> length = 0;        /* Longueur nulle */
  341.         ligne -> info1.bufsize = 0;
  342.         if( bufsize > 0 )
  343.         {
  344.             signale( "\n Erreur ds param bufsize lors de l'appel … insert_line" );
  345.         }
  346.     }
  347.  
  348.         
  349.     /*
  350.      * Cette ligne ne continue pas sur la suivante:
  351.      * (Cette ligne est suivie d'un CR LF)
  352.      */
  353.     ligne -> info1.continued = FALSE;
  354.  
  355.  
  356.     /*
  357.      * Lien avec la ligne pr‚c‚dente: 
  358.      */
  359.     prev_line -> next = ligne;
  360.                     
  361.     /*
  362.      * Lien avec la ligne suivante: 
  363.      */
  364.     if ( next_line !=NULL )        /* S'il y en a une... */
  365.     {
  366.         next_line -> prev = ligne;
  367.     }
  368.     else                                /* Si on vient d'ajouter la derniŠre ligne */
  369.     {
  370.         info_ptr -> lastline = ligne;        /* On sauve son adresse */
  371.     }
  372.     
  373.     /*
  374.      * Une ligne de plus: 
  375.      */
  376.     (info_ptr -> nb_lignes) ++;
  377.             
  378.     return    ligne;            /* Renvoi le ptr sur la nlle ligne */
  379. }
  380.  
  381.  
  382.  
  383. /*
  384.  * delete_line(-)
  385.  *
  386.  * Purpose:
  387.  * --------
  388.  * Suppression d'une ligne dans un texte quelconque
  389.  * (peut aussi supprimer des lignes stand-alone)
  390.  *
  391.  * History:
  392.  * --------
  393.  * 04.07.94: fplanque: Created
  394.  * 13.07.95: fplanque: gestion des stand-alone
  395.  */
  396. void    delete_line( 
  397.             TEXTLINE *    pTextLine,     /* In: Ligne … supprimer */
  398.             TEXTINFO    *    pTextInfo )    /* In: Texte ds lequel on efface */
  399. {
  400.     TEXTLINE    * pTextLine_prev = pTextLine -> prev;    /* Ligne pr‚c‚dante */
  401.     TEXTLINE    * pTextLine_next = pTextLine -> next;    /* Ligne suivante */
  402.  
  403.     /*
  404.      * Lien ligne pr‚c‚dente -> suivante:
  405.      */
  406.     if( pTextLine_prev != NULL )        /* S'il y en a une... */
  407.     {
  408.         pTextLine_prev -> next = pTextLine_next;
  409.     }
  410.     else if( pTextInfo != NULL )
  411.     {    /*
  412.          * Si la ligne n'est pas stand-alone:
  413.          */
  414.         pTextInfo -> firstline = pTextLine_next;
  415.     }
  416.     
  417.     /*
  418.      * Lien ligne suivante -> pr‚c‚dente: 
  419.      */
  420.     if ( pTextLine_next != NULL )        /* S'il y en a une... */
  421.     {
  422.         pTextLine_next -> prev = pTextLine_prev;
  423.     }
  424.     else if( pTextInfo != NULL )
  425.     {    /*
  426.          * Si la ligne n'est pas stand-alone:
  427.          */
  428.         pTextInfo -> lastline = pTextLine_prev;
  429.     }
  430.     
  431.     /*
  432.      * Une ligne de moins: 
  433.      */
  434.     if( pTextInfo != NULL )
  435.     {    /*
  436.          * Si la ligne n'est pas stand-alone:
  437.          */
  438.         (pTextInfo -> nb_lignes) --;
  439.     }
  440.             
  441.  
  442.     /*
  443.      * D‚truit r‚ellement la ligne:
  444.      */
  445.     free_String( pTextLine -> text );
  446.     FREE( pTextLine );
  447. }
  448.  
  449.  
  450. /*
  451.  * free_formatext(-)
  452.  *
  453.  * Purpose:
  454.  * --------
  455.  * Efface un texte formatt‚ de la m‚moire
  456.  *
  457.  * History:
  458.  * --------
  459.  * 1993: fplanque: Created
  460.  */
  461. void    free_formatext( 
  462.             TEXTINFO *textinfo )
  463. {    
  464.     /*
  465.      * On commence par effacer la derniŠre ligne: 
  466.      * (pour mieux lib‚rer la m‚moire...)
  467.      */
  468.     TEXTLINE    *current    = textinfo -> lastline;
  469.     TEXTLINE    *prev;
  470.  
  471.     /*
  472.      * Efface le texte: 
  473.      */    
  474.     while ( current !=NULL )    /* Efface ligne par ligne... */
  475.     {
  476.         prev = current -> prev;        /* Pointe sur ligne pr‚c‚dente */
  477.         if( current -> text != NULL )
  478.         {
  479.             FREE( current -> text );    /* Efface le texte associ‚ */
  480.         }
  481.         FREE( current );                /* Efface ligne courante */
  482.         current = prev;                /* Nlle ligne courante */
  483.     }
  484.     
  485.     /*
  486.      * Efface les infos sur le texte: 
  487.      */
  488.     FREE( textinfo );
  489. }
  490.  
  491.  
  492.  
  493. /*
  494.  * params_texte(-)
  495.  *
  496.  * Purpose:
  497.  * --------
  498.  * Dialogue user
  499.  * Change paramŠtres du texte d'une fenˆtre
  500.  *
  501.  * History:
  502.  * --------
  503.  * 1993: fplanque: Created
  504.  * 25.05.94: fplanque: adaptation au nouveau sch‚ma de TEXT_DRAWPAR
  505.  * 07.01.95: fplanque: gŠre nb lignes max dans les logs
  506.  */
  507. void    params_texte( 
  508.             const GRECT *start_box )
  509. {
  510.     int        exit_obj;                    /* Objet de sortie */
  511.     GRECT        form_box;                    /* Dimensions du formulaire */
  512.     /* Adr champs de saisie */
  513.     char    *    textsize = (M_pObj_FormParamsAffText[TEXTSIZE] .ob_spec.tedinfo) -> te_ptext;
  514.     char    *    piBsz_nbMaxLines = (M_pObj_FormParamsAffText[AFFLGMAX] .ob_spec.tedinfo) -> te_ptext;
  515.     int        edit_obj = TEXTSIZE;
  516.  
  517.     TEXT_DRAWPAR *    pTextDrawPar = G_wi_list_adr -> draw_ptr.pTextDrawPar;
  518.  
  519.     /*
  520.      * Fixe valeurs courantes ds formulaire: 
  521.      */
  522.     itoa( pTextDrawPar -> n_points, textsize, 10 );                    /* Conversion d‚cimale */
  523.     ltoa( pTextDrawPar -> l_nbLinesMax, piBsz_nbMaxLines, 10 );    /* Conversion d‚cimale */
  524.  
  525.     /*
  526.      * Affiche/gŠre/efface formulaire: 
  527.      */
  528.     /* App prend en charge souris */
  529.     WIND_UPDATE_BEG_MCTRL
  530.     open_dialog( M_pObj_FormParamsAffText, start_box, &form_box );
  531.  
  532.     exit_obj=ext_form_do( M_pObj_FormParamsAffText, &edit_obj );    /* Gestion de la boŒte */
  533.  
  534.     close_dialog( M_pObj_FormParamsAffText, exit_obj, start_box, &form_box );
  535.     /* AES peut reprendre la souris */
  536.     WIND_UPDATE_END_MCTRL
  537.  
  538.     /*
  539.      * Si confirmation: 
  540.      */
  541.     if ( exit_obj == AFTXTCNF )
  542.     {
  543.         int        old_cell_h = pTextDrawPar -> n_cell_h;
  544.  
  545.         /*
  546.          * Cherche nlle taille demand‚e: 
  547.          */
  548.         int        new_height = atoi( textsize );    /* Conversion */
  549.         int        char_w, char_h, cell_w, cell_h;
  550.  
  551.         /*
  552.          * Fixe nlle taille: 
  553.          */
  554.         vst_point( G_ws_handle, new_height, &char_w, &char_h, &cell_w, &cell_h );
  555.         /*    printf("New text format: chw=%d chh=%d clw=%d clh=%d\r", char_w, char_h, cell_w, cell_h); */
  556.  
  557.         /*
  558.          * Fixe nouveaux paramŠtres fenˆtre: 
  559.          */
  560.         pTextDrawPar -> n_points = new_height;        /* Haut en "points" */
  561.         pTextDrawPar -> n_char_h = char_h;
  562.         pTextDrawPar -> n_cell_w = cell_w;
  563.         pTextDrawPar -> n_cell_h = cell_h;
  564.  
  565.         pTextDrawPar -> l_nbLinesMax = atol( piBsz_nbMaxLines );    /* Conversion */
  566.     
  567.         /*
  568.          * Calcule nouvelle largeur & hauteur totale: 
  569.          */
  570.         calc_textSizeW( G_wi_list_adr );
  571.         calc_textSizeH( G_wi_list_adr );
  572.  
  573.         /*
  574.          * Calcule la nlle position: 
  575.          */            
  576.         /*    printf("Ancienne position: %lu, %d\n", G_wi_list_adr -> seen_y, old_cell_h); */
  577.  
  578.         G_wi_list_adr -> seen_y /= old_cell_h;    /* no de la ligne */
  579.         /*    printf("No de la ligne: %lu\n", G_wi_list_adr -> seen_y);    */
  580.  
  581.         G_wi_list_adr -> seen_y *= cell_h;            /* nlle psition en pixels */
  582.         /*    printf("Nlle position: %lu, %d\n", G_wi_list_adr -> seen_y, cell_h); */
  583.         
  584.  
  585.         /*
  586.          * Demande redraw: 
  587.          */
  588.         wi_resize( G_wi_list_adr );                /* New ascenseurs et repositionnement contenu si n‚cessaire */
  589.         send_fullredraw( G_wi_list_adr );        /* New contenu */
  590.     }
  591. }
  592.  
  593.  
  594.  
  595. /*
  596.  * -------- RESPRESENTATION D'UNE LIGNE DE TEXTE EN MEMOIRE ---------
  597.  */
  598.  
  599.  
  600. /*
  601.  * TextLine_CreateStandAlone(-)
  602.  *
  603.  * Cr‚ation d'une TEXTLINE seule 
  604.  * (pas rattach‚e … un texte quelconque)
  605.  * Sert par exemple pour un BUFFER de reception ds GetKeyboard en mode BUFFERING
  606.  *
  607.  * 13.07.95: fplanque: Created
  608.  */
  609. TEXTLINE * TextLine_CreateStandAlone(    /* Out: TEXTLINE cr‚‚e */
  610.                     int     bufsize )            /* In:  Taille buffer  */ 
  611. {
  612.     TEXTLINE    *    pTextLine;
  613.  
  614.     /*
  615.      * Cr‚ation d'une ligne en m‚moire: 
  616.      */    
  617.     pTextLine = (TEXTLINE *)    MALLOC( sizeof( TEXTLINE ) );
  618.     pTextLine -> prev = NULL;        /* Pointeur sur pTextLine pr‚c‚dente */
  619.     pTextLine -> next = NULL;        /* Pointeur sur pTextLine suivante */
  620.  
  621.     pTextLine -> text = (char*)MALLOC( bufsize );        /* Pointeur sur le texte */
  622.     pTextLine -> length = 0;
  623.     pTextLine -> info1.bufsize = bufsize;    /* Taille du buffer d'‚dition */
  624.         
  625.     /*
  626.      * Cette ligne ne continue pas sur la suivante:
  627.      */
  628.     pTextLine -> info1.continued = FALSE;
  629.  
  630.     return    pTextLine;            /* Renvoi le ptr sur la nlle ligne */
  631. }
  632.  
  633.  
  634. /*
  635.  * TextLine_Clear(-)
  636.  *
  637.  * Vide le buffer d'une ligne de texte
  638.  *
  639.  * 08.10.95: fplanque: Created
  640.  */
  641. void TextLine_Clear(
  642.             TEXTLINE    *    pTextLine ) /* In: Ligne … vider */
  643. {
  644.     pTextLine -> text[ 0 ] = '\0';
  645.     pTextLine -> length = 0;
  646. }
  647.  
  648.  
  649. /*
  650.  * -------------- RESPRESENTATION D'UN TEXTE EN MEMOIRE ------------------
  651.  */
  652.  
  653.  
  654. /*
  655.  * create_newText(-)
  656.  *
  657.  * Purpose:
  658.  * --------
  659.  * Cr‚er un nouveau texte dans 
  660.  * le DATAGROUP des textes
  661.  * qui doit ˆtre visible dans la top window
  662.  *
  663.  * Notes:
  664.  * ------
  665.  * Le texte cr‚‚ est on ne peut plus vide: longueur 0
  666.  *
  667.  * History:
  668.  * --------
  669.  * 18.06.94: created based on creer_rubrique()
  670.  * 19.06.94: le texte est maintenant cr‚‚ avec longueur 0 et pas 1
  671.  * 19.06.94: Mise en service DATABLOCK
  672.  * 22.11.94: am‚lioration des tests avant action
  673.  */
  674. void    create_newText( 
  675.             GRECT *start_box )
  676. {
  677.     DATAGROUP * datagroup;
  678.     
  679.     if(    G_wi_list_adr == NULL
  680.         || G_wi_list_adr -> class != CLASS_DIR )
  681.     {
  682.         ping();
  683.         return;
  684.     }
  685.  
  686.     datagroup = G_wi_list_adr -> datagroup;
  687.  
  688.     /*     
  689.      * V‚rifie que la fenˆtre sup‚rieure peut recevoir
  690.      * un nouveau texte:  
  691.      */
  692.     if( datagroup -> DataType != DTYP_TEXTS )
  693.     {
  694.         ping();
  695.         return;
  696.     }
  697.     else
  698.     {    /* 
  699.          * Oui, la fenˆtre peut recevoir un texte: 
  700.          * Demande nouveau nom et cr‚e datapage: 
  701.          */
  702.  
  703.         DATAPAGE    * pDataPage = create_newDataPage( 
  704.                                             "NOUVEAU TEXTE",
  705.                                             datagroup,
  706.                                             start_box );
  707.  
  708.         if( pDataPage != NULL )
  709.         {    /*
  710.              * Si cr‚ation OK:
  711.              * Assigne un texte vide … la datapage:
  712.              */
  713.             DATABLOCK * pDataBlock = create_stdDataBlock();
  714.  
  715.             pDataPage -> data.dataBlock = pDataBlock;
  716.         }
  717.     }
  718. }
  719.  
  720.  
  721.  
  722. /*
  723.  * charge_texte(-)
  724.  *
  725.  * Purpose:
  726.  * --------
  727.  * Charge un texte en m‚moire
  728.  * Le texte est charg‚ sous forme formatt‚e et non compacte
  729.  *
  730.  * History:
  731.  * --------
  732.  * 1993: fplanque: Created
  733.  * 25.05.94: fplanque: utilise nouveau create_TextInfo()
  734.  */
  735. int    charge_texte( 
  736.             TEXT_DRAWPAR  * * ppTextDrawPar )
  737. {
  738.     int            ouverture_ok=0;    /* Va t'on r‚ussir … charger le texte ? */
  739.     FTA            fta;                    /* File transfer area */
  740.  
  741.     TEXTINFO      *    p_TextInfo = create_TextInfo( );
  742.     
  743.     *ppTextDrawPar = create_TextDrawPar( p_TextInfo, 10 /* bidon */ );
  744.  
  745.     if ( *ppTextDrawPar != NULL )
  746.     {
  747.         /*
  748.          * Chargement du texte: 
  749.          */
  750.         fta .textinfo = p_TextInfo;
  751.         ouverture_ok = load_file( "Voir un texte (ASCII)",
  752.                                         F_TEXTE_ASCII, &fta ); /* Charge un texte */
  753.     }
  754.  
  755.     if( ouverture_ok == 0)
  756.     {
  757.         free_formatext( p_TextInfo );
  758.         if ( *ppTextDrawPar != NULL )
  759.             FREE( *ppTextDrawPar );
  760.     }
  761.     
  762.     return    ouverture_ok;
  763. }
  764.  
  765.  
  766.  
  767. /*
  768.  * sauve_texte(-)
  769.  *
  770.  * Purpose:
  771.  * --------
  772.  * Sauve un texte r‚sident en m‚moire
  773.  * sur disque
  774.  * sous forme formatt‚e et non compacte
  775.  *
  776.  * History:
  777.  * --------
  778.  * 31.05.94: fplanque: Created
  779.  */
  780. void    sauve_texte( 
  781.             TEXTINFO *    pTextInfo )    /* In: Ptr sur texte … sauver */
  782. {
  783.     FTA            fta;                    /* File transfer area */
  784.  
  785.     /*
  786.      * Sauvegarde du texte: 
  787.      */
  788.     fta .textinfo = pTextInfo;
  789.     save_file( "Sauver un texte (ASCII)", F_TEXTE_ASCII, &fta );
  790. }
  791.  
  792.  
  793. /*
  794.  * save_text2datapage(-)
  795.  *
  796.  * Purpose:
  797.  * --------
  798.  * Sauve un texte r‚sident en m‚moire
  799.  * sous forme compact‚e dans une datapage
  800.  *
  801.  * Suggest:
  802.  * --------
  803.  * on pourrait directement transmettre le datablock
  804.  *
  805.  * History:
  806.  * --------
  807.  * 19.06.94: fplanque: Created
  808.  * 28.08.94: fplanque: appelle maintenant save_text2datapage
  809.  */
  810. int    save_text2datapage(             /* In: FALSE0 si ‚chec sauvegarde */
  811.             TEXTINFO *    pTextInfo,    /* In: Ptr sur texte … sauver */
  812.             DATAPAGE    *    pDataPage )    /* In: Datapage ds laquelle il faut sauver */
  813. {
  814.     DATABLOCK * pDataBlock = pDataPage -> data.dataBlock;
  815.  
  816.     /*
  817.      * Compacte le texte:
  818.      */
  819.     pDataBlock -> ul_length =    compact_text(
  820.                                             pTextInfo -> firstline -> next,
  821.                                             FMTMODE_NEARBINARY,
  822.                                             &( pDataBlock -> p_block ) );
  823.  
  824.     return    TRUE_1;            
  825. }
  826.  
  827.  
  828.  
  829. /*
  830.  * create_TextInfo(-)
  831.  *
  832.  * Purpose:
  833.  * --------
  834.  * Cr‚ation de l'en-tˆte (ligne 0 - vide) d'un texte formatt‚
  835.  * pour son stockage en m‚moire
  836.  *
  837.  * History:
  838.  * --------
  839.  * 1993: fplanque: Created
  840.  * 25.05.94: fplanque: ajout des inits curseur
  841.  */
  842. TEXTINFO * create_TextInfo( void )    /* out: Ptr sur TEXTINFO cr‚e */
  843. {
  844.     TEXTLINE    *    pTextLine;
  845.     TEXTINFO *    pTextInfo;
  846.  
  847.     /* 
  848.      * Cr‚e une ligne bidon (vide): 
  849.      */
  850.     pTextLine = (TEXTLINE *) MALLOC( sizeof( TEXTLINE ) );
  851.     if ( pTextLine == NULL )        /* Si pas assez de m‚moire */
  852.     {
  853.         alert( NOMEM_OPENDOC );        /* Pas assez de mem pour ouvrir doc */
  854.         return    NULL;                    /* Ouverture … ‚chou‚ */
  855.     }        
  856.  
  857.     pTextLine -> prev = NULL;            /* Pas de ligne pr‚c‚dente */
  858.     pTextLine -> next = NULL;            /* Pas de ligne suivante */
  859.     pTextLine -> length = 0;            /* Longueur nulle */
  860.     pTextLine -> text = NULL;            /* Pas de texte */
  861.  
  862.  
  863.     /*
  864.      * Cr‚e une zone d'infos: 
  865.      */
  866.     pTextInfo = (TEXTINFO *) MALLOC( sizeof( TEXTINFO ) );
  867.     if( pTextInfo == NULL )                /* Si pas assez de m‚moire */
  868.     {
  869.         alert( NOMEM_OPENDOC );            /* Pas assez de mem pour ouvrir doc */
  870.         FREE( pTextLine );                /* Supprime head d‚j… cr‚‚ */
  871.         return    NULL;                        /* Ouverture … ‚chou‚ */
  872.     }        
  873.     
  874.     pTextInfo -> firstline    = pTextLine;        /* 1Šre ligne */
  875.     pTextInfo -> lastline    = pTextLine;        /* derniŠre ligne */
  876.     pTextInfo -> nb_lignes     = 0;                    /* Pas de lignes */
  877.  
  878.     return    pTextInfo;
  879. }
  880.  
  881.  
  882.  
  883. /*
  884.  * create_justified_text(-)
  885.  *
  886.  * Purpose:
  887.  * --------
  888.  * Cr‚e une structure texte en m‚moire et y place un texte
  889.  * que l'on formatte pour l'occasion
  890.  * Le texte a formatter doit ˆtre au format REZO
  891.  *
  892.  * Suggest:
  893.  * --------
  894.  * PROVISOIRE: Contient une boite d'alerte pouvant bloquer le serveur...
  895.  *
  896.  * History:
  897.  * --------
  898.  * 1993: fplanque: Created
  899.  * 25.05.94: fplanque: Use new create_TextInfo()
  900.  */
  901. TEXTINFO *    create_justified_text( 
  902.                     char        *    p_text,            /* In: ptr sur bloc m‚moire contenant le texte compact‚ */
  903.                     size_t         size_text,        /* In: Longueur du texte compact */
  904.                     int            max_line_len )    /* In: Longueur de ligne maximale */
  905. {
  906.     /*
  907.      * Adresse des infos sur le nouveau texte 
  908.      */
  909.     TEXTINFO    * pTextInfo = create_TextInfo();
  910.  
  911.     /*
  912.      * Cr‚e le header du texte en mem: 
  913.      */
  914.     if ( pTextInfo != NULL )
  915.     {    /*
  916.          * Formatte le texte (BLOC->lignes) pour son affichage: 
  917.          */
  918.         format_text( pTextInfo, pTextInfo -> lastline,
  919.                          p_text, size_text, FMTMODE_REZO, max_line_len ); 
  920.     }
  921.  
  922.     return    pTextInfo;
  923. }
  924.  
  925.  
  926.  
  927. /*
  928.  * format_text(-)
  929.  *
  930.  * Purpose:
  931.  * --------
  932.  * Formatte un texte compact sous forme de bloc
  933.  * en texte formatt‚ (suite de lignes)
  934.  * et insere ce texte formatt‚ dans un autre
  935.  *
  936.  * History:
  937.  * --------
  938.  * 1993: fplanque: Created
  939.  * 19.06.94: Ajoute eventuellement une ligne vide … la fin
  940.  * 28.08.94: Gestion du mode d'interpr‚tation des caractŠres
  941.  */
  942. void format_text( 
  943.         TEXTINFO *    textinfo,             /* In: Zone d'infos pour texte formatt‚ */
  944.         TEXTLINE *    start_line,            /* In: Ligne … laquelle il faut ins‚rer le texte qu'on va formatter */
  945.         char        *    text_adr,            /* Ptr sur texte compact en m‚moire */
  946.         size_t         text_length,        /* Longueur de ce texte compact */
  947.         int            mode,                 /* In: FMTMODE_NEARBINARY, FNTMODE_REZO */
  948.         int            max_line_len )        /* In: Longueur maximale d'une ligne */
  949. {
  950.     #define    WATCH_FORMATEXT    NO0
  951.  
  952.     /* 
  953.      * Variables Source: 
  954.      */
  955.     char        *text_ptr = text_adr;    /* Pointeur sur caractŠre en cours */
  956.     char        *text_end = text_adr + text_length -1;
  957.     char        *space_ptr;                /* Pointeur sur espace */
  958.     int        last_space;                /* Position du dernier espace */
  959.     char        car;                        /* CaractŠre en cours! */
  960.     BOOL        B_carriageReturn;        /* On a d‚tect‚ un CR ou CR/LF */
  961.     char        prec_car;                /* CaractŠre pr‚c‚dent */
  962.             
  963.     /*
  964.      * Buffer interm‚diaire: 
  965.      */
  966.     char        *buffer_ptr;            /* Pointeur ds buffer interm‚diaire */
  967.     int        line_length;            /* Longueur de la ligne en cours */
  968.  
  969.     /*
  970.      * Variables Destination 
  971.      */
  972.     char            *new_line;                        /* Adr nlle ligne */
  973.     TEXTLINE        *curr_line = start_line;    /* Adr new infos-ligne */
  974.  
  975.     /*
  976.      * Mode d'extraction: 
  977.      */
  978.     BOOL    cr_lf;
  979.     BOOL    filter;
  980.  
  981.     if( mode == FMTMODE_REZO )
  982.     {    /*
  983.          * Format REZO:
  984.          */
  985.         cr_lf = FALSE0;        /* Fin de Ý indiqu‚e par CR */
  986.         filter = TRUE_1;        /* Filtrage des codes <32 */
  987.     }
  988.     else        
  989.     {    /*
  990.           * Format FMTMODE_NEARBINARY:
  991.           */
  992.         cr_lf = TRUE_1;        /* Fin de Ý indiqu‚e par CR/LF */
  993.         filter = FALSE0;        /* Tous les codes sauf 0 sont affich‚s */
  994.     }
  995.  
  996.     #if     WATCH_FORMATEXT
  997.         printf("\nTexte avec justification:\n\033p");
  998.     #endif
  999.  
  1000.     if( text_ptr != NULL )
  1001.     {
  1002.         /*
  1003.          * --------------------
  1004.          * D‚coupage en lignes: 
  1005.          * --------------------
  1006.          */
  1007.         while ( text_ptr <= text_end )
  1008.         {    /*
  1009.              * D‚coupe une ligne: 
  1010.              */
  1011.             buffer_ptr = G_tmp_buffer;
  1012.             last_space= 0;                /* Position du dernier espace */
  1013.             prec_car = 0;                /* CaractŠre pr‚c‚dent */
  1014.             line_length = 0;
  1015.     
  1016.             while( line_length < max_line_len && text_ptr <= text_end )
  1017.             {    /*
  1018.                  * Tant que pas long max ligne ou fin de texte atteinte:
  1019.                  */
  1020.                 car = *(text_ptr ++);                /* Prend 1 caractŠre */
  1021.                 B_carriageReturn = FALSE0;            /* Pour l'instant on est pas sur un cr(lf) */
  1022.     
  1023.                 /*
  1024.                  * Contr“le fin de ligne ‚ventuelle: 
  1025.                  */
  1026.                 if ( cr_lf && car == LF && prec_car == CR )
  1027.                 {    /*
  1028.                      * Si on attend des fins de lignes CR LF et qu'on en a une: 
  1029.                      */
  1030.                     B_carriageReturn = TRUE_1;
  1031.                     if( !filter )
  1032.                     {    /*
  1033.                          * Si on a pas filtr‚ le LF: 
  1034.                          */
  1035.                         buffer_ptr--;
  1036.                         line_length--;
  1037.                     }
  1038.                      break;
  1039.                 }
  1040.                 else if( !cr_lf && car == CR)
  1041.                 {    /*
  1042.                      * Si un CR indique une fin de ligne/Ý
  1043.                      */
  1044.                     B_carriageReturn = TRUE_1;
  1045.                     break;
  1046.                 }
  1047.     
  1048.                 /*
  1049.                  * Recopie caractŠre dans buffer: 
  1050.                  */
  1051.                 if( car >= ' ' || (!filter && car > '\0') )
  1052.                 {    /*
  1053.                      * Si on accepte le caractŠre: 
  1054.                      */
  1055.                     *(buffer_ptr++) = car;        /* Sauve caractŠre */
  1056.                     line_length ++;                /* 1 car de + */
  1057.     
  1058.                     if ( car==' ' )                    /* si espace */
  1059.                     {
  1060.                         space_ptr = text_ptr;        /* Position a laquelle on peut reprendre si on coupe … cet espace */
  1061.                         last_space = line_length;    /* m‚morise sa position */
  1062.                     }
  1063.                 }
  1064.     
  1065.                 /*
  1066.                  * On va passer au car suivant: 
  1067.                  */
  1068.                 prec_car = car;
  1069.             }
  1070.             
  1071.             /*
  1072.              * ------------------------------------
  1073.              * Ajustement pour ne pas couper de mot: 
  1074.              * ------------------------------------
  1075.              */    
  1076.             if ( line_length == max_line_len )
  1077.             {    /*
  1078.                   * Si on est sorti parce que fin de
  1079.                   * ligne sur p‚riph‚rique de sortie: 
  1080.                   */
  1081.                 if ( car > ' ' )
  1082.                 {    /*
  1083.                      * Si le dernier code est un caractŠre 
  1084.                      */
  1085.                     if ( last_space > 0 )
  1086.                     {    /*
  1087.                          * s'il y a au moins 1 espace dans la ligne:
  1088.                          */
  1089.                         line_length = last_space;
  1090.                         buffer_ptr = G_tmp_buffer + last_space;
  1091.                         text_ptr = space_ptr;        /* On continuera ici */
  1092.                     }
  1093.                 }
  1094.             }
  1095.     
  1096.             /*
  1097.              * Termine ligne par \0 : 
  1098.              */
  1099.             *buffer_ptr = '\0';
  1100.             
  1101.             /*
  1102.              * ------------------------------------
  1103.              * On va maintenant extraire la ligne:
  1104.              * ------------------------------------
  1105.              */
  1106.             if ( line_length )
  1107.             {    /*
  1108.                  * Si la ligne n'est pas vide: 
  1109.                  */
  1110.                 new_line = STRDUP( G_tmp_buffer );        /* Cr‚e ligne d‚finitive */
  1111.                 #if     WATCH_FORMATEXT
  1112.                     printf(">%s\n",new_line);
  1113.                 #endif
  1114.             }
  1115.             else
  1116.             {    /*
  1117.                   * Ligne vide: 
  1118.                   */
  1119.                 new_line = NULL;
  1120.                 #if     WATCH_FORMATEXT
  1121.                     printf("(vide)>\n");
  1122.                 #endif
  1123.             }
  1124.     
  1125.             /*
  1126.              * Ajoute la ligne au texte: 
  1127.              */
  1128.             curr_line = insert_line( curr_line, new_line, NIL, textinfo );    
  1129.         }
  1130.     }
  1131.  
  1132.     /*
  1133.      * Contr“le s'il faut ajouter une ligne vide … la fin:
  1134.      */
  1135.     if( B_carriageReturn == TRUE_1 || textinfo -> nb_lignes == 0 )
  1136.     {    /*
  1137.          * Si le texte source se termine par un CR/(LF)
  1138.          * ou si le texte dest ne contient aucune ligne -> impossible d'afficher un eventuel curseur
  1139.          * Ajoute une ligne vide: 
  1140.          */
  1141.         curr_line = insert_line( curr_line, NULL, NIL, textinfo );    
  1142.     }
  1143.  
  1144.     #if     WATCH_FORMATEXT
  1145.         printf("\033q");            /* Stop inverse vid‚o */
  1146.     #endif
  1147.  
  1148. }
  1149.  
  1150.  
  1151.  
  1152. /*
  1153.  * text_IsFilled(-)
  1154.  *
  1155.  * Purpose:
  1156.  * --------
  1157.  * D‚termine si un texte contient des informations utiles
  1158.  * ou juste du garbage junk!
  1159.  *
  1160.  * Algorythm:
  1161.  * ----------  
  1162.  * Renvoie TRUE dŠs qu'on trouve un car >32
  1163.  *
  1164.  * History:
  1165.  * --------
  1166.  * 09.12.94: fplanque: Created
  1167.  */
  1168. BOOL    text_IsFilled(
  1169.             TEXTINFO    * pTextInfo )
  1170. {
  1171.     /*
  1172.      * Ligne courante
  1173.      * (la1Šre est tjs vide mais bon on la teste qd mˆme...)
  1174.      */
  1175.     TEXTLINE    *    pTextLine_Curr = pTextInfo -> firstline;
  1176.     char         *    psz_text;
  1177.     int            i;
  1178.  
  1179.     while( pTextLine_Curr != NULL )
  1180.     {
  1181.         psz_text = pTextLine_Curr -> text;
  1182.     
  1183.         if( psz_text != NULL )
  1184.         {
  1185.             for( i = 0; i < pTextLine_Curr -> length; i++ )
  1186.             {
  1187.                 if( psz_text[ i ] > ' ' )
  1188.                 {
  1189.                     return    TRUE_1;
  1190.                 }
  1191.             }
  1192.         }
  1193.     
  1194.         pTextLine_Curr = pTextLine_Curr -> next;
  1195.     }
  1196.     
  1197.     return    FALSE0;    /* rien trouv‚ */
  1198. }
  1199.  
  1200.  
  1201. /*
  1202.  * compact_text(-)
  1203.  *
  1204.  * Purpose:
  1205.  * --------
  1206.  * Transforme un texte r‚sident en m‚moire
  1207.  * en une forme compact‚e
  1208.  *
  1209.  * Algorythm:
  1210.  * ----------  
  1211.  * - Calcule taille que ‡a va prendre
  1212.  * - Cr‚e bloc de sauvegarde
  1213.  * - Ecrit le nouveau texte dans le bloc
  1214.  * - r‚ajuste taille bloc
  1215.  *
  1216.  * History:
  1217.  * --------
  1218.  * 28.08.94: fplanque: Created by extraction from fill_textfield() & 
  1219.  * 24.08.94: tient compte pour caractŠre entre 2 ligne dans calcul longueur
  1220.  * 24.08.94: GESTION DU FLAG CONTINUED.
  1221.  * 01.12.94: retourne un bloc de longueur paire si FMTMODE_REZO
  1222.  * 15.12.94: pas de saut de ligne sur derniere ligne en mode FMTMODE_NEARBINARY
  1223.  */
  1224. size_t    compact_text(                    /* Out: Longueur du texte compact */
  1225.         TEXTLINE    *    pTextLine_First,    /* In: 1Šre ligne … compacter */
  1226.         int            mode,                    /* In: FMTMODE_REZO ou FMTMODE_NEARBINARY */
  1227.         char        **    ppBuf_compact )    /* In: adr Buffer contenant texte compact */
  1228. {
  1229.     char     *     pBuf;
  1230.     char    *    piBuf;
  1231.     size_t    s_RealLength;
  1232.  
  1233.     /*
  1234.      * -------------------------------------------------
  1235.      * Calcul d'une MAJORATION de la longueur totale qu'occupera le message: 
  1236.      * Pour ensuite r‚server la m‚moire
  1237.      * -------------------------------------------------
  1238.      */
  1239.     size_t        s_length     = 0;
  1240.     TEXTLINE *    pTextLine = pTextLine_First;        /* Commence … la premiŠre ligne: */
  1241.  
  1242.     while( pTextLine != NULL )
  1243.     {    /*
  1244.          * Tant qu'on est pas sur la derniŠre ligne: 
  1245.          *
  1246.          * Ajoute long de la ligne courante 
  1247.          * +2 pour mettre soit un espace, soit un CR soit un CR/LF en fonction de continued
  1248.          */
  1249.         s_length += pTextLine -> length +2;
  1250.         pTextLine = pTextLine -> next;                /* Passe … la ligne suivante */
  1251.     }
  1252.     s_length ++;                 /* Place pour \0 FINAL */
  1253.     s_length ++;                 /* Place pour un eventuel \0 suppl‚mentaire si besoin d'ajuster la parit‚ (FMTMODE_REZO) */
  1254.  
  1255.     /*
  1256.      * R‚serve zone m‚moire: 
  1257.      */
  1258.     pBuf = (char *) MALLOC( s_length );        /* R‚serve m‚moire */
  1259.  
  1260.     /*
  1261.      * -------------------------------------------------
  1262.      * Recopie les lignes: 
  1263.      * -------------------------------------------------
  1264.      */        
  1265.     pTextLine = pTextLine_First;        /* Commence … la premiŠre ligne: */
  1266.     piBuf = pBuf;                            /* Commence … ‚crire au d‚but de la chaine */
  1267.     while( pTextLine != NULL )
  1268.     {    /*
  1269.           * Tant qu'on est pas sur la derniŠre ligne: 
  1270.           */
  1271.         memcpy( piBuf, pTextLine -> text, pTextLine -> length );    /* Recopie la ligne */
  1272.         piBuf += pTextLine -> length;            /* Avance le pointeur */
  1273.  
  1274.         if( pTextLine -> info1.continued )
  1275.         {    /*
  1276.              * Le paragraphe continue sur la ligne suivante:
  1277.              * Note: si les mots sont plus longs que la ligne on riske de se
  1278.              * retrouver avec des espaces en trop. Ptet qu'on pourrait tester
  1279.              * si la ligne est pleine et si oui: pas d'espace ins‚r‚!
  1280.              */
  1281.             *(piBuf++) = ' ';    /* InsŠre espace */
  1282.         }
  1283.         else
  1284.         {    /*
  1285.              * Fin de paragraphe:
  1286.              */
  1287.             if( mode == FMTMODE_REZO )
  1288.             {
  1289.                 *(piBuf++) = CR;    /* InsŠre fin de Ý */
  1290.             }
  1291.             else if( mode == FMTMODE_NEARBINARY )
  1292.             {
  1293.                 if( pTextLine -> next != NULL )
  1294.                 {    /*
  1295.                      * Si on est pas sur la derniŠre ligne (15.12.94)
  1296.                      */
  1297.                     *(piBuf++) = CR;    /* InsŠre fin de ligne */
  1298.                     *(piBuf++) = LF;
  1299.                 }
  1300.             }
  1301.             else
  1302.             {    /*
  1303.                  * Mode FMTMODE_SGLETEXTLINE:
  1304.                  * Normalement, le cas d'un saut de paragraphe en mode
  1305.                  * FMTMODE_SGLETEXTLINE n'arrive que sur la derniŠre ligne-‚cran
  1306.                  * auquel cas on ignore.
  1307.                  * Cependant: si ‡a arrivait ailleurs: on remplace par un espace
  1308.                  * car on a pas de droit de mettre plusieurs paragraphes!
  1309.                  */
  1310.                 if( pTextLine -> next != NULL )
  1311.                 {    /*
  1312.                      * Si on est (anormalement) pas sur la derniŠre ligne!
  1313.                      */
  1314.                     *(piBuf++) = ' ';    /* InsŠre Espace */
  1315.                 }
  1316.             }
  1317.         }
  1318.  
  1319.         /*
  1320.          * Passe … la ligne suivante:
  1321.          */
  1322.         pTextLine = pTextLine -> next;                
  1323.     }
  1324.     
  1325.     /*
  1326.      * S'occupe des \0 … la fin: 
  1327.      */
  1328.     *(piBuf++) = '\0';                                    /* Fin de la chaŒne */
  1329.  
  1330.     /*
  1331.      * R‚ajuste taille du bloc:
  1332.      */
  1333.     s_RealLength = piBuf - pBuf;
  1334.  
  1335.     /*
  1336.      * Un bloc en mode FMTMODE_REZO ou FMTMODE_SGLETEXTLINE
  1337.      * doit OBLIGATOIREMENT avoir une longueur paire:
  1338.      */
  1339.     if( mode == FMTMODE_REZO || mode == FMTMODE_SGLETEXTLINE)
  1340.     {
  1341.         s_RealLength = (s_RealLength+1) & PARITY;
  1342.         pBuf[ s_RealLength-1 ] = '\0';        /* Bouche trou ‚ventuel du … la parit‚ */
  1343.     }
  1344.     /* printf( "Real length: %lu   Max: %lu\n", s_RealLength, s_length ); */
  1345.  
  1346.     if( s_RealLength < s_length )
  1347.     {
  1348.         pBuf = (char *) REALLOC( pBuf, s_RealLength );
  1349.     }
  1350.  
  1351.     /*
  1352.      * Retourne bloc:
  1353.      */
  1354.     *ppBuf_compact = pBuf;
  1355.  
  1356.     return    s_RealLength;    
  1357. }
  1358.  
  1359.  
  1360.  
  1361. /*
  1362.  * -------------------- EDITION D'UN TEXTE EN MEMOIRE --------------------
  1363.  */
  1364.  
  1365.  
  1366. /*
  1367.  * textEdit_addChar(-)
  1368.  *
  1369.  * Purpose:
  1370.  * --------
  1371.  * Ajoute un caractŠre dans une ligne de texte
  1372.  *
  1373.  * History:
  1374.  * --------
  1375.  * 20.08.94: fplanque: Extracted form winEdit_...
  1376.  * 21.08.94: fplanque: tient compte longueur max ligne 
  1377.  * 08.10.95: v‚rifie qu'on insŠre pas aprŠs la fin de la ligne
  1378.  */
  1379. void    textEdit_addChar( 
  1380.             TEXTLINE *    pTextLine,        /* In: Ligne a ‚diter */
  1381.             int            n_col,            /* In: O— ajouter le car [0..] */
  1382.             char            c_car,            /* In: CaractŠre … ins‚rer */
  1383.             int            n_maxlen )        /* In: Longueur maximale d'une ligne */
  1384. {
  1385.     int        n_BufSize    = pTextLine -> info1.bufsize;
  1386.     char    *    psz_text        = pTextLine -> text;
  1387.     char    *    spsz_CarPos;            /* static pointer */
  1388.  
  1389.     /*
  1390.      * V‚rifie qu'on est ds le champ du possible:
  1391.      */
  1392.     if( n_col >= n_maxlen )
  1393.     {
  1394.         return;
  1395.     }
  1396.     if( n_col > pTextLine -> length )
  1397.     {
  1398.         signale( "BUG: Impossible d'ins‚rer un car aprŠs la fin de la ligne!" );
  1399.         return;
  1400.     }
  1401.     
  1402.     /*
  1403.      * Ajuste ‚ventuellement la taille du buffer:
  1404.      */
  1405.     if( n_BufSize <= pTextLine -> length )
  1406.     {    /*
  1407.           * Normalement le cas < ne devrait JAMAIS arriver!
  1408.           * Si le buffer ne peut pas accueillir de caractŠres suppl‚mentaires:
  1409.           * On le rallonge:
  1410.           */
  1411.          n_BufSize = min( n_BufSize + BUFFER_INCREASE_STEP, n_maxlen );
  1412.          pTextLine -> info1.bufsize = n_BufSize;
  1413.          
  1414.         if( psz_text != NULL )
  1415.         {
  1416.             psz_text = (char *) REALLOC( psz_text, n_BufSize + 1 );    /* +1 pour \0 final */
  1417.         }
  1418.         else
  1419.         {
  1420.             psz_text = (char *) MALLOC( n_BufSize + 1 );        /* +1 pour \0 final */
  1421.             psz_text[ 0 ] = '\0';            /* ChaŒne vide */
  1422.         }
  1423.         pTextLine -> text = psz_text;
  1424.  
  1425.         /* printf( "New buf: [%s]  ", pS_text ); */
  1426.     }
  1427.  
  1428.     
  1429.     /*
  1430.      * InsŠre le caractŠre:
  1431.      */
  1432.     spsz_CarPos = &( psz_text[ n_col ] );
  1433.  
  1434.     memcpy( spsz_CarPos +1, spsz_CarPos, pTextLine -> length - n_col + 1 );    /* D‚cale fin de la ligne  (+1 pour le \0) */
  1435.     (pTextLine -> length) ++;         /* Nouvelle longueur de ligne */
  1436.  
  1437.     *spsz_CarPos = c_car;        /* Ecrit caractŠre ds buffer */
  1438. }
  1439.  
  1440.  
  1441.  
  1442. /*
  1443.  * textEdit_delChar(-)
  1444.  *
  1445.  * Purpose:
  1446.  * --------
  1447.  * Efface un caractŠre dans une ligne de texte
  1448.  *
  1449.  * History:
  1450.  * --------
  1451.  * 20.08.94: fplanque: Extracted form winEdit_...
  1452.  * 20.08.94: correction d'un +1 inutile
  1453.  */
  1454. void    textEdit_delChar( 
  1455.             TEXTLINE *    pTextLine,        /* In: Ligne a ‚diter */
  1456.             int            n_col )            /* In: Car … effacer [0..] */
  1457. {
  1458.     if( n_col < (pTextLine -> length) )
  1459.     {    /*
  1460.          *    On ne va effacer que si on se trouve effectivement
  1461.          * … _l'int‚rieur_ d'une ligne
  1462.          */
  1463.     
  1464.         char    * pS_CarPos = &( (pTextLine -> text)[ n_col ] );
  1465.     
  1466.         /*
  1467.          * Efface le caractŠre:
  1468.          */
  1469.         memcpy( pS_CarPos, pS_CarPos+1, (pTextLine -> length) - n_col );    /* D‚cale fin de la ligne */
  1470.         /*
  1471.          * Fixe nouvelle longueur de la ligne!
  1472.          */
  1473.         (pTextLine -> length)--; 
  1474.  
  1475.     }
  1476. }
  1477.  
  1478.  
  1479. /*
  1480.  * -------------- AFFICHAGE D'UN TEXTE DANS UNE FENETRE ------------------
  1481.  */
  1482.  
  1483.  
  1484.  
  1485. /*
  1486.  * create_TextDrawPar(-)
  1487.  *
  1488.  * Purpose:
  1489.  * --------
  1490.  * Cr‚ation de paramŠtres d'affichage 
  1491.  * pour le texte formatt‚ fourni en paramŠtre
  1492.  *
  1493.  * Algorythm:
  1494.  * ----------  
  1495.  * Agit uniquement si pTextInfo != NULL
  1496.  *
  1497.  * History:
  1498.  * --------
  1499.  * 25.05.94: fplanque: Created
  1500.  * 07.01.95: Fixe nb lignes max … garder en m‚moirepour les logs
  1501.  */
  1502. TEXT_DRAWPAR *    create_TextDrawPar(                 /* Out: Ptr sur infos d'affichage g‚n‚r‚es */
  1503.                         TEXTINFO *    pTextInfo,        /* In:  Ptr sur texte … afficher */
  1504.                         long            l_nbLinesMax )    /* In:  Nbre max de lignes qu'on veut garder en m‚moire (pour les logs, pas pour les ‚ditables) */
  1505. {
  1506.     TEXT_DRAWPAR * pTextDrawPar;
  1507.  
  1508.     if( pTextInfo == NULL )
  1509.     {
  1510.         return    NULL;
  1511.     }
  1512.  
  1513.     /*
  1514.      * Cr‚e une zone d'infos: 
  1515.      */
  1516.     pTextDrawPar = (TEXT_DRAWPAR *) MALLOC( sizeof( TEXT_DRAWPAR ) );
  1517.     if ( pTextDrawPar == NULL )        /* Si pas assez de m‚moire */
  1518.     {
  1519.         alert( NOMEM_OPENDOC );            /* Pas assez de mem pour ouvrir doc */
  1520.         return    NULL;                        /* Ouverture … ‚chou‚ */
  1521.     }        
  1522.  
  1523.     pTextDrawPar -> pTextInfo    = pTextInfo;                    /* Texte … afficher */
  1524.     pTextDrawPar -> pTextLine_top    = pTextInfo -> firstline;    /* 1Šre ligne fenˆtre (Ligne 0) */
  1525.     pTextDrawPar -> l_topline    = 0;                            /* Ligne no 0 */
  1526.  
  1527.     pTextDrawPar -> n_points    = G_std_text .points;    /* Haut en "pts" */
  1528.     pTextDrawPar -> n_char_h    = G_std_text .char_h;    /* Haut car */
  1529.     pTextDrawPar -> n_cell_w    = G_std_text .cell_w;    /* Larg. emplacement */
  1530.     pTextDrawPar -> n_cell_h    = G_std_text .cell_h;    /* Haut emplacement */
  1531.  
  1532.     /*
  1533.      * Nombre de lignes qu'on s'autorise … garder en m‚moire
  1534.      * (les textes ‚ditables n'ont pas de limite)
  1535.      */
  1536.     pTextDrawPar -> l_nbLinesMax    = l_nbLinesMax;                        
  1537.  
  1538.     /*
  1539.      * Par d‚faut le texte n'est pas ‚ditable et n'a donc pas de curseur:
  1540.      */
  1541.     pTextDrawPar -> pTextLine_edit = NULL;        /* Pas de ligne en cours d'‚dition */
  1542.     pTextDrawPar -> l_LigneCsr         = 0;            /* Ligne 0 */
  1543.     pTextDrawPar -> n_ColCsr         = 0;            /* Colonne 0 */
  1544.         
  1545.     return    pTextDrawPar;
  1546. }
  1547.  
  1548.  
  1549.  
  1550.  
  1551. /*
  1552.  * open_text(-)
  1553.  *
  1554.  * Purpose:
  1555.  * --------
  1556.  * Param‚trage d'une fenˆtre texte en vue de son ouverture
  1557.  *
  1558.  * History:
  1559.  * --------
  1560.  * 1993: fplanque: Created
  1561.  * 25.05.94: fplanque: retrait du param TEXTLINE *text_ptr
  1562.  * 25.05.94: adaptation au nouveau sch‚ma de TEXT_DRAWPAR
  1563.  * 26.09.94: gestion des TYP_ERRORS extraite en proc ind‚pendante
  1564.  */
  1565. void open_text( 
  1566.         WIPARAMS      *    pWiParams, 
  1567.         TEXT_DRAWPAR *    pTextDrawPar )
  1568. {
  1569.     TEXTINFO *    pTextInfo = pTextDrawPar -> pTextInfo;
  1570.  
  1571.     /*
  1572.      * Param‚trage de la fenˆtre: 
  1573.      */
  1574.  
  1575.     /* 
  1576.      * Pointe sur infos texte: 
  1577.      */
  1578.     pWiParams -> content_ptr.textInfo= pTextInfo;    
  1579.  
  1580.     /* 
  1581.      * Pointe sur informations texte en RAM: 
  1582.      */
  1583.     pWiParams -> draw_ptr.pTextDrawPar    = pTextDrawPar;    
  1584.  
  1585.     calc_textSizeW( pWiParams );
  1586.     calc_textSizeH( pWiParams );
  1587.     pWiParams -> h_step = (pTextDrawPar -> n_cell_w) *8;    /* Saut par 8 car */
  1588.     pWiParams -> v_step = pTextDrawPar -> n_cell_h;        /* Saut par ligne */
  1589.  
  1590.     /*
  1591.      * Options menu: 
  1592.      */
  1593.     pWiParams -> menu_options.savedisk    = TRUE_1;    /* On peut sauver le contenu de la fenˆtre */
  1594.     pWiParams -> menu_options.compile    = TRUE_1;    /* On peut compiler le texte */
  1595.     pWiParams -> menu_options.affichage = PARAFF_TEXT;    /* On peut r‚gler la taille du texte */
  1596.  
  1597.     /*
  1598.      * Autres: 
  1599.      */
  1600.     if ( pWiParams -> type == TYP_DEBUG )
  1601.     {    /*
  1602.          * Si on a affaire … la fenˆtre d'infos debug 
  1603.          */
  1604.         G_debug_window = pWiParams;     /* Adr de la fenˆtre de debug */
  1605.         menu_ienable( G_menu_adr, SYSTEMST, 1);    /* Enable System status */
  1606.     }
  1607.     
  1608.     /*
  1609.      * Edition/curseur:
  1610.      */
  1611.      if ( pWiParams -> type == TYP_TEXT )
  1612.     {    /*
  1613.          * Si on a affaire … la fenˆtre contenant un texte: 
  1614.          * Ligne en cours d'‚dition: juste aprŠs la topline (:ligne0:vide)
  1615.          * (la topline n'est pas tjs visible entiŠrement
  1616.          */
  1617.         pTextDrawPar -> pTextLine_edit = pTextDrawPar -> pTextLine_top -> next;
  1618.         pTextDrawPar -> l_LigneCsr         = 1;            /* Ligne 1 */
  1619.         pTextDrawPar -> n_ColCsr          = 0;            /* Colonne 0 */
  1620.     }
  1621. }
  1622.  
  1623.  
  1624.  
  1625.  
  1626.  
  1627. /*
  1628.  * calc_textSizeW(-)
  1629.  *
  1630.  * Purpose:
  1631.  * --------
  1632.  * Calcule et fixe largeur totale du texte
  1633.  *
  1634.  * Algorythm:
  1635.  * ----------  
  1636.  * On rajoute +8 car il y a 4 pix … gauche et … droite
  1637.  *
  1638.  * History:
  1639.  * --------
  1640.  * 1993: fplanque: Created
  1641.  * 25.05.94: utilise maintenant un TEXT_DRAWPAR en paramŠtre
  1642.  * 13.06.94: s‚par‚ calcul de W et de H, TEXT_DRAWPAR maintenant extrait de pTextDrawPar
  1643.  */
  1644. void    calc_textSizeW( 
  1645.                 WIPARAMS     *    pWiParams  )
  1646. {
  1647.     TEXT_DRAWPAR * pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  1648.  
  1649.     pWiParams -> total_w    = 
  1650.         G_def_text_width * pTextDrawPar -> n_cell_w + 8;        /* Largeur max */
  1651. }
  1652.  
  1653.  
  1654. /*
  1655.  * calc_textSizeH(-)
  1656.  *
  1657.  * Purpose:
  1658.  * --------
  1659.  * Calcule et fixe hauteur totale du texte
  1660.  *
  1661.  * Algorythm:
  1662.  * ----------  
  1663.  * Rajoute TEXT_VBOTTOM_COMPENSATE parce qu'un emplacement standard a en
  1664.  *    g‚n‚ral des lignes vides au dessus des caractŠres et
  1665.  *    pas au dessous. Cette ligne suppl‚mentaire est donc 
  1666.  *    destin‚e … compenser (un ptit peu) en fin de fenˆtre
  1667.  *
  1668.  * History:
  1669.  * --------
  1670.  * 1993: fplanque: Created
  1671.  * 25.05.94: utilise maintenant un TEXT_DRAWPAR en paramŠtre
  1672.  * 13.06.94: s‚par‚ calcul de W et de H, TEXT_DRAWPAR maintenant extrait de pTextDrawPar
  1673.  */
  1674. void    calc_textSizeH( 
  1675.             WIPARAMS      *    pWiParams )
  1676. {
  1677.     TEXT_DRAWPAR * pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  1678.     TEXTINFO         * pTextInfo = pTextDrawPar -> pTextInfo;
  1679.  
  1680.     pWiParams -> total_h            = 
  1681.             (pTextInfo -> nb_lignes)             /* Nombre de lignes */
  1682.         *    (pTextDrawPar -> n_cell_h )        /* Hauteur d'une ligne */
  1683.         +    (pTextDrawPar -> n_cell_h /TEXT_VMARGINS_LINERATIO * 2 )            /* parce qu'un 1/3 de ligne au dessus et au dessous */
  1684.         +    TEXT_VBOTTOM_COMPENSATE;
  1685. }
  1686.  
  1687.  
  1688.  
  1689. /*
  1690.  * textLine_OffsetY(-)
  1691.  *
  1692.  * Purpose:
  1693.  * --------
  1694.  * Fournit la position verticale d'une ligne
  1695.  * en pixels par rapport au d‚but du document texte [0...]
  1696.  *
  1697.  * Notes:
  1698.  * --------
  1699.  * Inutilis‚ pour l'instant...
  1700.  *
  1701.  * History:
  1702.  * --------
  1703.  * 26.05.94: fplanque: Created
  1704.  */
  1705. unsigned    long    textLine_OffsetY(                        /* Out: Offset de la ligne par rapport au d‚but du document */
  1706.                         TEXT_DRAWPAR *    pTextDrawPar,    /* In:  ParamŠtres d'affichage du texte    */
  1707.                         long                l_line )            /* In:  Ligne dont on veut connaitre l'offset [1...] (ne pas demander la ligne0: negatif) */
  1708. {
  1709.     int    n_line_h = pTextDrawPar -> n_cell_h;
  1710.  
  1711.     return    (    l_line * n_line_h
  1712.                     - n_line_h + (n_line_h /3)     );    /* Laisse un peu d'espace blanc */
  1713.  
  1714. }
  1715.  
  1716.  
  1717.  
  1718. /*
  1719.  * vmove_text(-)
  1720.  *
  1721.  * Purpose:
  1722.  * --------
  1723.  * Mouvement vertical sur une fenˆtre texte
  1724.  *
  1725.  * History:
  1726.  * --------
  1727.  * 1993: fplanque: Created
  1728.  */
  1729. void    vmove_text(
  1730.             WIPARAMS *pWiParams, 
  1731.             unsigned long new_pos )
  1732. {
  1733.     long    curr_pos;
  1734.     TEXT_DRAWPAR * pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  1735.     TEXTINFO         * pTextInfo     = pTextDrawPar -> pTextInfo;
  1736.         
  1737.     /*
  1738.      * On se place sur la top-line actuelle: 
  1739.      */
  1740.     TEXTLINE    *    pTextLine_top    = pTextDrawPar -> pTextLine_top;
  1741.     long            l_topline        = pTextDrawPar -> l_topline; 
  1742.  
  1743.     /*
  1744.      * Hauteur d'une ligne en pixels: 
  1745.      */
  1746.     int        line_h = pTextDrawPar -> n_cell_h;
  1747.  
  1748.     /*
  1749.      * Position actuelle de la fenetre par rapport au texte: 
  1750.      */
  1751.     unsigned long    start_pos = pWiParams -> seen_y;
  1752.  
  1753.     /*
  1754.      * Recherche quelle est la NOUVELLE ligne du haut de la fenˆtre: 
  1755.      */
  1756.     if    ( new_pos > start_pos )            /* Si on avance ds le texte: */
  1757.     {
  1758.         curr_pos = ( start_pos / line_h + 1) * line_h ;  /* Commence sur ligne actuelle */
  1759.         while( curr_pos <= new_pos )
  1760.         {    /*
  1761.              * Tant qu'on a pas d‚pass‚ la position demand‚e: 
  1762.              */
  1763.             curr_pos += line_h;
  1764.             l_topline ++;                                        /* Ligne suivante */
  1765.             pTextLine_top = pTextLine_top -> next;        /* on passe sur ligne suivante */
  1766.         }
  1767.  
  1768.         /*
  1769.          * Contr“le validit‚ Top-Line
  1770.          */
  1771.         if( l_topline > (pTextInfo -> nb_lignes) )
  1772.         {
  1773.             ping();                                            /* ANORMAL */
  1774.             l_topline = pTextInfo -> nb_lignes;
  1775.         }
  1776.     }
  1777.     else                                        /* Si on recule dans le texte: */
  1778.     {
  1779.         curr_pos = ( start_pos / line_h ) * line_h ;  /* Commence sur ligne actuelle */
  1780.         while( curr_pos > new_pos )
  1781.         {    /*
  1782.              * Tant qu'on a pas d‚pass‚ la position demand‚e: 
  1783.              */
  1784.             curr_pos -= line_h;
  1785.             l_topline --;                                        /* Ligne Pr‚c‚dente */
  1786.             pTextLine_top = pTextLine_top -> prev;        /* on passe sur ligne suivante */
  1787.         }
  1788.  
  1789.         /*
  1790.          * Contr“le validit‚ Top-Line
  1791.          */
  1792.         if( l_topline < 0 )
  1793.         {
  1794.             ping();                                            /* ANORMAL */
  1795.             l_topline = 0;
  1796.         }
  1797.     }
  1798.  
  1799.     /*
  1800.      * M‚morise nlle top-line: 
  1801.      */
  1802.     pTextDrawPar -> pTextLine_top = pTextLine_top;
  1803.     pTextDrawPar -> l_topline = l_topline;
  1804.     
  1805.     /* printf( "\r Top Line = %ld ", l_topline ); */
  1806. }
  1807.  
  1808.  
  1809.  
  1810. /*
  1811.  * move_TextView_vert(-)
  1812.  *
  1813.  * Purpose:
  1814.  * --------
  1815.  * D‚place la vue d'une fenˆtre texte vers la position indiqu‚e
  1816.  * cel… met … jour les pointeurs sur topline etc... 
  1817.  * et effectue le redraw
  1818.  *
  1819.  * History:
  1820.  * --------
  1821.  * 26.05.94: fplanque: Created
  1822.  */
  1823. void    move_TextView_vert(
  1824.             WIPARAMS        *    pWiParams, 
  1825.             unsigned long    ul_new_VertTextPos )
  1826. {
  1827.     unsigned long    ul_old_VertTextPos = pWiParams -> seen_y;
  1828.  
  1829.     /*
  1830.      * Fixe nouvelle topline:
  1831.      */
  1832.     vmove_text( pWiParams, ul_new_VertTextPos );
  1833.     
  1834.     /*
  1835.      * Sauve nouvelle position:
  1836.      */
  1837.     pWiParams -> seen_y = ul_new_VertTextPos;
  1838.  
  1839.     /*
  1840.      * R‚affiche l'ascenseur:
  1841.      */
  1842.     set_slider_y( pWiParams );
  1843.  
  1844.     /*
  1845.      * Fait scroller le contenu de la fenˆtre vers la nouvelle position: 
  1846.      */
  1847.     vscroll_window( pWiParams, ul_old_VertTextPos, ul_new_VertTextPos );
  1848.  
  1849. }
  1850.  
  1851.  
  1852. /*
  1853.  * move_TextView_horiz(-)
  1854.  *
  1855.  * Purpose:
  1856.  * --------
  1857.  * D‚place la vue d'une fenˆtre texte vers la position indiqu‚e
  1858.  * cel… met … jour certaines variables... et effectue le redraw
  1859.  *
  1860.  * History:
  1861.  * --------
  1862.  * 30.05.94: fplanque: Created based on move_TextView_vert
  1863.  */
  1864. void    move_TextView_horiz(
  1865.             WIPARAMS        *    pWiParams, 
  1866.             unsigned long    ul_new_HorizTextPos )
  1867. {
  1868.     unsigned long    ul_old_HorizTextPos = pWiParams -> seen_x;
  1869.  
  1870.     /*
  1871.      * Sauve nouvelle position:
  1872.      */
  1873.     pWiParams -> seen_x = ul_new_HorizTextPos;
  1874.  
  1875.     /*
  1876.      * R‚affiche l'ascenseur:
  1877.      */
  1878.     set_slider_x( pWiParams );
  1879.  
  1880.     /*
  1881.      * Fait scroller le contenu de la fenˆtre vers la nouvelle position: 
  1882.      */
  1883.     hscroll_window( pWiParams, ul_old_HorizTextPos, ul_new_HorizTextPos );
  1884.  
  1885. }
  1886.  
  1887. /*
  1888.  * move_TextViewToPos(-)
  1889.  *
  1890.  * Purpose:
  1891.  * --------
  1892.  * D‚place la vue d'une fenˆtre texte 
  1893.  * de maniŠre … ce que la position demand‚e soit visible … l'‚cran
  1894.  * cel… met … jour certaines variables... 
  1895.  * et demande le redraw
  1896.  * 
  1897.  * History:
  1898.  * --------
  1899.  * 04.07.94: fplanque: Created
  1900.  */
  1901. void    move_TextViewToPos(
  1902.             WIPARAMS    *    pWiParams,
  1903.             long            l_ligne,        /* In: No de la ligne qu'n veut rendre visible */
  1904.             int            nb_lignes,    /* In: Nbre de lignes devant ˆtre visibles imp‚rativement, normalement 1 */
  1905.             int            n_col,        /* In: Colonne … rendre visible */
  1906.             int            nb_cols )    /* In: Nbre de colonnes devant ˆtre vues imp‚rativement, normalement 1 */
  1907. {
  1908.     TEXT_DRAWPAR *    pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  1909.     /*
  1910.      * Coordonn‚es de la zone texte:
  1911.      */
  1912.     int    n_workXGauche = pWiParams -> work_x;
  1913.     int    n_workXDroit  = get_workXDroit( pWiParams );
  1914.     int    n_workYHaut      = pWiParams -> work_y;
  1915.     int    n_workYBas      = get_workYBas( pWiParams );
  1916.     /*
  1917.      * Calcule coord pix Y sup‚rieure 
  1918.      * de la premiŠre ligne affich‚e (topline): 
  1919.      */
  1920.     int    line_h = pTextDrawPar -> n_cell_h;                        /* Hauteur d'une ligne en pixels */
  1921.     int    line_y = n_workYHaut                                         /* Pos Y sup de la ligne en cours d'affichage (init pourla topline) */
  1922.                         - line_h + (line_h /TEXT_VMARGINS_LINERATIO) /* Laisse un peu d'espace blanc */
  1923.                         - (int)((pWiParams -> seen_y) % line_h);        /* Tient compte du fait que la ligne peut ˆtre d‚cal‚e par rapport … son alignement vertical initial */
  1924.     int    cell_w = pTextDrawPar -> n_cell_w;            /* Largeur d'un emplacement caractŠre en pixels */
  1925.     int    first_col = ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) / cell_w;
  1926.     int    line_x = n_workXGauche                                    /* Position en pixels pour l'affichage des lignes de texte */
  1927.                             - ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) % cell_w;    /* Laisse une marge de 4 pixels sur la gauche */
  1928.  
  1929.     /*
  1930.      * Coordonn‚es de la position demand‚e:
  1931.      */
  1932.     int    n_PosYHaut    = line_y + (int)(l_ligne - pTextDrawPar->l_topline) * line_h;                    
  1933.     int    n_PosYBas    = n_PosYHaut + nb_lignes * line_h -1;
  1934.     int    n_PosX        = line_x + (n_col - first_col) * cell_w;
  1935.  
  1936.     /*
  1937.      * Contr“le de la position verticale:
  1938.      */
  1939.     if( n_PosYHaut < n_workYHaut )
  1940.     {    /* 
  1941.          * La position demand‚e est au dessus de la partie visible
  1942.          * ou seulement partiellement affich‚e:
  1943.          */
  1944.         unsigned long    ul_new_VertTextPos = l_max ( 0,
  1945.                                                     (l_ligne - 1) * line_h );
  1946.         /*
  1947.          * D‚place la vue: 
  1948.          */
  1949.         move_TextView_vert( pWiParams, ul_new_VertTextPos );
  1950.     }
  1951.     else if( n_PosYBas > n_workYBas )
  1952.     {    /* 
  1953.          * La position demand‚e est au dessous de la partie visible,
  1954.          * seulement partiellement affich‚e:
  1955.          */
  1956.         unsigned long    ul_new_VertTextPos = l_min ( 
  1957.                                 pWiParams -> total_h 
  1958.                                  - pWiParams -> seen_h + line_h,
  1959.                                 (l_ligne + nb_lignes) * line_h 
  1960.                                  - pWiParams -> seen_h
  1961.                                  - (line_h/TEXT_VMARGINS_LINERATIO + TEXT_VBOTTOM_COMPENSATE) );
  1962.         /*
  1963.          * D‚place la vue: 
  1964.          */
  1965.         move_TextView_vert( pWiParams, ul_new_VertTextPos );
  1966.     }
  1967.  
  1968.  
  1969.     /*
  1970.      * Contr“le de la position horizontale:
  1971.      */
  1972.     if( n_PosX < n_workXGauche )
  1973.     {    /* 
  1974.          * La pos demand‚e est … gauche de la partie visible
  1975.          * ou seulement partiellement affich‚e:
  1976.          */
  1977.         unsigned long    ul_new_HorizTextPos =
  1978.                                 l_max ( 0, n_col * cell_w );
  1979.         /*
  1980.          * D‚place la vue: 
  1981.          */
  1982.         move_TextView_horiz( pWiParams, ul_new_HorizTextPos );
  1983.     }
  1984.     else if( n_PosX + (nb_cols) * cell_w > n_workXDroit )
  1985.     {    /* 
  1986.          * En fait c'est n_PosX + ()*cell_w -1 mais bon...
  1987.          * Le car sous curseur est … droite de la partie visible
  1988.          * ou seulement partiellement affich‚:
  1989.          */
  1990.         unsigned long    ul_new_HorizTextPos = 
  1991.                             l_min ( pWiParams -> total_w - pWiParams -> seen_w,
  1992.                              TEXT_HMARGINS_WIDTH + (n_col + nb_cols) * cell_w 
  1993.                              - pWiParams -> seen_w );
  1994.         /*
  1995.          * D‚place la vue: 
  1996.          */
  1997.         move_TextView_horiz( pWiParams, ul_new_HorizTextPos );
  1998.     }
  1999.  
  2000. }
  2001.  
  2002.  
  2003.  
  2004. /*
  2005.  * add_textinf(-)
  2006.  *
  2007.  * Purpose:
  2008.  * --------
  2009.  * Ajoute une ligne de texte au bas d'une fenˆtre d'infos
  2010.  *
  2011.  * Suggest:
  2012.  * --------
  2013.  * Optimize redraw
  2014.  *
  2015.  * History:
  2016.  * --------
  2017.  * 1993: fplanque: Created
  2018.  * 25.05.94: adaptation au nouveau format TEXT_DRAWPAR
  2019.  * 30.05.94: appelle maintenant aussi redraw_textline()
  2020.  * 13.06.94: update ascenseur simplifi‚e: pas besoin de contr“ler si la fenˆtre d‚passe la fin du document
  2021.  * 25.09.94: fait maintenant appel … text_addLineToEnd()
  2022.  * 07.01.95: contr“le du nbre de lignes maximum; optimisation du calcul taille totale
  2023.  */
  2024. void    add_textinf( 
  2025.             WIPARAMS     * pWiParams,     /* In: Fenˆtre vis‚e */
  2026.             const char    * inf )            /* In: ModŠle de texte … dupliker puis ins‚rer */
  2027. {
  2028.     unsigned long    old_pos;            /* Ancienne position Y */
  2029.     signed long        new_pos;
  2030.     TEXT_DRAWPAR * pTextDrawPar;
  2031.     TEXTINFO         *    textinfo;
  2032.     int                n_cell_h;
  2033.  
  2034.     if ( pWiParams == NULL )
  2035.     {     /*
  2036.           * Si la fenˆtre demand‚e a ‚t‚ referm‚e entre temps:
  2037.          */
  2038.          return;
  2039.     }
  2040.          
  2041.  
  2042.     /* 
  2043.      * Infos sur le texte: 
  2044.      */
  2045.     pTextDrawPar    = pWiParams -> draw_ptr.pTextDrawPar;
  2046.     textinfo            = pTextDrawPar -> pTextInfo;
  2047.     n_cell_h            = pTextDrawPar -> n_cell_h;
  2048.  
  2049.     /*
  2050.      * Ajoute la ligne ds le texte en RAM:
  2051.      */
  2052.     text_addLineToEnd( textinfo, inf );
  2053.  
  2054.     /*
  2055.      * Calcule nlle taille du texte: 
  2056.      */
  2057.     (pWiParams -> total_h) += n_cell_h;
  2058.  
  2059.     /*
  2060.      * On se place sur la fin du texte: 
  2061.      */
  2062.     new_pos = l_max( 0, pWiParams->total_h - pWiParams->seen_h);
  2063.     vmove_text( pWiParams, new_pos );        /* Fixe nlle position */
  2064.     old_pos = pWiParams -> seen_y;            /* Sauve ancienne position */
  2065.     pWiParams -> seen_y = new_pos;
  2066.  
  2067.     /*
  2068.      * V‚rifie si le texte ne devient pas trop long:
  2069.      */
  2070.     while( textinfo -> nb_lignes > pTextDrawPar -> l_nbLinesMax )
  2071.     {    /*
  2072.          * On a atteint le nbre maximum de lignes autoris‚:
  2073.          */
  2074.         TEXTLINE * pTextLine_ToErase = textinfo -> firstline -> next;
  2075.  
  2076.         if( (pTextDrawPar -> l_topline) <= 1 )
  2077.         {    /*
  2078.              * On rique d'effacer une ligne partiellement visible:
  2079.              */
  2080.             break;
  2081.         }
  2082.          
  2083.         /*
  2084.          * M‚morise nlle top-line: 
  2085.          */
  2086.         (pTextDrawPar -> l_topline) --;
  2087.  
  2088.         (pWiParams -> seen_y) -= n_cell_h;
  2089.     
  2090.         /*
  2091.          * Efface la plus acienne ligne (no 1):
  2092.          */
  2093.         delete_line( pTextLine_ToErase, textinfo );
  2094.  
  2095.         /*
  2096.          * Calcule nlle taille du texte: 
  2097.          */
  2098.         (pWiParams -> total_h) -= n_cell_h;
  2099.     }
  2100.  
  2101.  
  2102.     /*
  2103.      * Fixe nlle taille et position ascenseur: 
  2104.      */
  2105.     set_slider_h( pWiParams );            /* Fix taille slider vertical */
  2106.     set_slider_y( pWiParams );            /* Fix position slider vertical */
  2107.  
  2108.     /*
  2109.      * -------
  2110.      * Redraw:
  2111.      * -------
  2112.      */
  2113.     {
  2114.     /* Variables: */
  2115.     int                szone_x, szone_y, szone_w, szone_h;
  2116.     int                line_h    = pTextDrawPar -> n_cell_h;        /* Hauteur d'une ligne */
  2117.     unsigned long    text_lastpixline = (textinfo -> nb_lignes) * line_h + line_h /3;    /* Avec les pixels blancs du haut */
  2118.  
  2119.     /*
  2120.      * Bloque ‚cran: 
  2121.      */
  2122.     int    noOverlap = start_WINDRAW( pWiParams );
  2123.  
  2124.     /*
  2125.      * Coordonn‚es de la zone de travail: 
  2126.      */
  2127.     szone_x    = pWiParams -> work_x;
  2128.     szone_y    = pWiParams -> work_y;
  2129.     szone_w    = pWiParams -> seen_w;
  2130.     szone_h    = pWiParams -> seen_h;
  2131.  
  2132.     /*
  2133.      * R‚duit … la partie qui se trouve vraiment sur l'‚cran: 
  2134.      */
  2135.     rcintersect(    G_x_mini, G_y_mini, G_w_maxi, G_h_maxi,
  2136.                           &szone_x, &szone_y, &szone_w, &szone_h );
  2137.  
  2138.  
  2139.     /*
  2140.      * Teste s'il faut scroller ou pas: 
  2141.      */
  2142.     if ( new_pos > old_pos )
  2143.     {    /* 
  2144.          * Il faut scroller car la derniŠre ligne ne pouvait ˆtre 
  2145.          * affich‚e entiŠrement: 
  2146.          */
  2147.         if( noOverlap == FALSE0 )
  2148.         {    /*
  2149.              * La fenˆtre n'est pas en 1 seul bloc:
  2150.              * impossible de scroller: 
  2151.              * Effectue un redraw imm‚diat: 
  2152.              */
  2153.             redraw( pWiParams, G_x_mini, G_y_mini, G_w_maxi, G_h_maxi, CTRL_OK );    /* Redraw complet */
  2154.         }
  2155.         else
  2156.         {    /* 
  2157.              * Si la fenˆtre est au top: on peut la faire scroller: 
  2158.              */
  2159.  
  2160.             /* Variables: */
  2161.             long    deplacement = new_pos - old_pos;
  2162.             long    text_h = text_lastpixline - old_pos - line_h;
  2163.             long    used_h = l_min( text_h, szone_h );
  2164.  
  2165.             /*
  2166.              * Teste si on peut scroller un bout d'‚cran ou si le saut est trop grand 
  2167.              */
  2168.             if ( deplacement < used_h )
  2169.             {    /*
  2170.                  * On peut scroller un morceau: 
  2171.                  */
  2172.                 int    bloc_size = (int)(used_h - deplacement);
  2173.                 
  2174.                 graf_mouse( M_OFF, NULL);            /* Efface le ptr souris */
  2175.  
  2176.                 /* Coordonn‚es source, destination: */
  2177.                 G_pxyarray[0]=szone_x;             /* Coord source */
  2178.                 G_pxyarray[1]=szone_y + (int)deplacement;
  2179.                 G_pxyarray[2]=szone_x + szone_w -1;
  2180.                 G_pxyarray[3]=G_pxyarray[1] + bloc_size -1;
  2181.                 G_pxyarray[4]=szone_x;            /* Coord destination */
  2182.                 G_pxyarray[5]=szone_y;
  2183.                 G_pxyarray[6]=G_pxyarray[2];
  2184.                 G_pxyarray[7]=szone_y + bloc_size -1;
  2185.                 /* D‚placement d'un bloc vers le haut sur l'‚cran logique: */
  2186.                 vro_cpyfm( G_ws_handle, S_ONLY, G_pxyarray,
  2187.                               &G_plogMFDB, &G_plogMFDB);
  2188.             
  2189.                 graf_mouse( M_ON, 0);                /* Affiche le ptr souris */
  2190.  
  2191.                 /*
  2192.                  * Que reste-t-il … afficher: 
  2193.                  */
  2194.                 szone_y += bloc_size;
  2195.                 szone_h -= bloc_size;
  2196.                 
  2197.             }
  2198.         
  2199.             /*
  2200.              * Affiche ce qui n'a pas encore ‚t‚ trait‚ par scroll: 
  2201.              */
  2202.             redraw( pWiParams, szone_x, szone_y, szone_w, szone_h , CTRL_OK );
  2203.         }
  2204.     }
  2205.     else
  2206.     {    /*
  2207.          * Pas besoin de scroller, il y a assez de place: 
  2208.          * Affiche ligne: 
  2209.          */
  2210.         redraw_textline( pWiParams, textinfo -> lastline, textinfo -> nb_lignes, 0, NIL_1 );
  2211.     }
  2212.  
  2213.     /*
  2214.      * rend le contr“le de l'‚cran: 
  2215.      */
  2216.     end_WINDRAW();
  2217.  
  2218.     }
  2219.  
  2220. }
  2221.  
  2222.  
  2223.  
  2224.  
  2225. /*
  2226.  * complete_textinf(-)
  2227.  *
  2228.  * Purpose:
  2229.  * --------
  2230.  * ComplŠte une ligne de texte au bas d'une fenˆtre d'infos
  2231.  * Cette ligne est suppos‚e visible: pas de scroll n‚cessaire
  2232.  *
  2233.  * History:
  2234.  * --------
  2235.  * 1993: fplanque: Created
  2236.  * 25.05.94: introduced TEXT_DRAWPAR
  2237.  * 30.05.94: appelle maintenant aussi redraw_textline()
  2238.  * 30.05.94: Mise … jour de la longueur de la ligne
  2239.  */
  2240. void    complete_textinf(
  2241.             WIPARAMS * pWiParams, 
  2242.             const char * inf )
  2243. {
  2244.     if ( pWiParams != NULL )
  2245.     { /*
  2246.         * Si la fenˆtre demande n'a pas ‚t‚ referm‚e entre temps 
  2247.         * Infos sur le texte: 
  2248.         */
  2249.         TEXT_DRAWPAR * pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  2250.         TEXTINFO    *textinfo = pTextDrawPar -> pTextInfo;
  2251.         TEXTLINE    *lastline = textinfo -> lastline;
  2252.         /*
  2253.          * Adr derniŠre ligne: 
  2254.          */
  2255.         char        *last_text = lastline -> text;
  2256.         char        *new_text;
  2257.         /* 
  2258.          * Variables: 
  2259.          */
  2260.         int        old_len;            /* Ancienne longueur */
  2261.         int        new_len;            /* Nouvelle longueur (totale) */
  2262.     
  2263.         /*
  2264.          * Longueur de la derniŠre ligne, avant modif: 
  2265.          */
  2266.         old_len = (int) strlen ( last_text );
  2267.         /*
  2268.          * Longueur qu'on va y ajouter: 
  2269.          */
  2270.         new_len = old_len + (int) strlen ( inf );
  2271.     
  2272.         /* 
  2273.          * ComplŠte la derniŠre ligne: 
  2274.          */
  2275.         new_text = (char *) REALLOC( last_text, new_len +1 );    /* +1 pour '\0' final */
  2276.         strcat( new_text, inf );
  2277.         lastline -> text = new_text;
  2278.  
  2279.         /*
  2280.          * Fixe nouvelle longueur de la derniŠre ligne:
  2281.          */
  2282.         lastline -> length = new_len;
  2283.         
  2284.         /*
  2285.          * On ne Calcule pas nlle taille du texte 
  2286.          * parce qu'on considŠre que ‡a rentre en largeur! 
  2287.          */
  2288.  
  2289.         /* 
  2290.          * R‚serve ‚cran: 
  2291.          */
  2292.         start_WINDRAW( NULL );
  2293.  
  2294.         /*
  2295.          * Affiche morceau de ligne: 
  2296.          */
  2297.         /*    redraw( pWiParams,
  2298.                         pWiParams -> work_x + old_len * car_w +4,
  2299.                         (int) (pWiParams -> work_y + text_lastpixline - pWiParams -> seen_y - line_h),
  2300.                         inf_len * car_w,
  2301.                         line_h,
  2302.                         TAKE_CTRL ); */
  2303.         redraw_textline( pWiParams, lastline, textinfo -> nb_lignes, old_len, NIL_1 );
  2304.  
  2305.         /*
  2306.          * rend le contr“le de l'‚cran: 
  2307.          */
  2308.         end_WINDRAW();
  2309.     }
  2310. }
  2311.  
  2312.  
  2313.  
  2314.  
  2315. /*
  2316.  * ------------------ EDITION D'UN TEXTE DS UNE FENETRE -----------------
  2317.  */
  2318.  
  2319.  
  2320. /*
  2321.  * winEdit_ProcessKey(-)
  2322.  *
  2323.  * Purpose:
  2324.  * --------
  2325.  * Traite une touche tap‚e dans une fenˆtre d'‚dition texte
  2326.  *
  2327.  * History:
  2328.  * --------
  2329.  * 25.05.94: fplanque: Created
  2330.  * 26.05.94: extension des possibilit‚s
  2331.  */
  2332. void    winEdit_ProcessKey(
  2333.             WIPARAMS *    pWiParams,        /* In: fenˆtre concern‚e */ 
  2334.             unsigned        u_kbd_state,    /* In: Etat des touches sp‚ciales */
  2335.             int            n_ScanCode,        /* In: ScanCode touche press‚e */
  2336.             char            c_car )            /* In: CaractŠre correspondant */
  2337. {
  2338.     /* printf( "\r ScanCode=%X ", n_ScanCode ); */
  2339.  
  2340.     if( u_kbd_state & (K_LSHIFT | K_RSHIFT) )
  2341.     {    /*
  2342.          * Si touche SHIFT press‚e:
  2343.          */
  2344.         TEXT_DRAWPAR *    pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  2345.  
  2346.         switch( n_ScanCode )
  2347.         {
  2348.             case    STSCAN_LEFT:
  2349.                 /*
  2350.                  * D‚but de ligne:
  2351.                  */
  2352.                 winEdit_MoveCsr( pWiParams, 0, -(pTextDrawPar -> n_ColCsr) );
  2353.                 break;
  2354.     
  2355.             case    STSCAN_RIGHT:
  2356.                 /*
  2357.                  * Fin de ligne:
  2358.                  */
  2359.                 winEdit_MoveCsr( pWiParams, 0, 
  2360.                     (pTextDrawPar -> pTextLine_edit -> length)-(pTextDrawPar -> n_ColCsr)  );
  2361.                 break;
  2362.     
  2363.             case    STSCAN_UP:
  2364.             case    STSCAN_DOWN:
  2365.             {    /*
  2366.                  * Page vers le haut:
  2367.                  * Page vers le bas:
  2368.                  */
  2369.                 int    n_line_h    = pTextDrawPar -> n_cell_h;
  2370.                 int    nb_LignesEcran = max( 1, (pWiParams -> seen_h) / n_line_h - 1);
  2371.                 int    nb_LignesDeplacement;
  2372.                 long    l_new_VertTextPos;
  2373.                 
  2374.                 /*
  2375.                  * D‚termine d‚placement & nouvelle position:
  2376.                  */
  2377.                 if( n_ScanCode == STSCAN_UP )
  2378.                 {
  2379.                     nb_LignesDeplacement  = - nb_LignesEcran;
  2380.                      l_new_VertTextPos = l_max( 0, 
  2381.                          pWiParams -> seen_y + nb_LignesDeplacement * n_line_h );
  2382.                 }
  2383.                 else
  2384.                 {
  2385.                     nb_LignesDeplacement  =  nb_LignesEcran;
  2386.                      l_new_VertTextPos = l_min( pWiParams -> total_h - pWiParams -> seen_h, 
  2387.                          pWiParams -> seen_y + nb_LignesDeplacement * n_line_h );
  2388.                      l_new_VertTextPos = MAX( l_new_VertTextPos, 0 );                
  2389.                 }
  2390.  
  2391.             
  2392.                 /*
  2393.                  * D‚place la vue: 
  2394.                  */
  2395.                 move_TextView_vert( pWiParams, l_new_VertTextPos );
  2396.  
  2397.                 /*
  2398.                  * D‚place le curseur: 
  2399.                  */
  2400.                 winEdit_MoveCsr( pWiParams, nb_LignesDeplacement, 0 );
  2401.  
  2402.             }
  2403.                 break;
  2404.     
  2405.             default:
  2406.                 if( c_car >= ' ' )
  2407.                 {
  2408.                     winEdit_TypeCar( pWiParams, c_car );
  2409.                 }
  2410.     
  2411.         }
  2412.     }
  2413.     else if( u_kbd_state == 0 )
  2414.     {    /*
  2415.          * Pas de touche sp‚ciale press‚e:
  2416.          */
  2417.         switch( n_ScanCode )
  2418.         {
  2419.             case    STSCAN_BS:
  2420.                 /*
  2421.                  * Backspace:
  2422.                  */
  2423.                 winEdit_DelCar( pWiParams, TRUE );
  2424.                 break;
  2425.  
  2426.             case    STSCAN_UP:
  2427.                 winEdit_MoveCsr( pWiParams, -1, 0 );
  2428.                 break;
  2429.             
  2430.             case    STSCAN_LEFT:
  2431.                 winEdit_MoveCsr( pWiParams, 0, -1 );
  2432.                 break;
  2433.     
  2434.             case    STSCAN_RIGHT:
  2435.                 winEdit_MoveCsr( pWiParams, 0, +1 );
  2436.                 break;
  2437.     
  2438.             case    STSCAN_DOWN:
  2439.                 winEdit_MoveCsr( pWiParams, +1, 0 );
  2440.                 break;
  2441.  
  2442.             case    STSCAN_DEL:
  2443.                 /*
  2444.                  * Delete:
  2445.                  */
  2446.                 winEdit_DelCar( pWiParams, FALSE );
  2447.                 break;
  2448.         
  2449.             default:
  2450.                 switch( c_car )
  2451.                 {
  2452.                     case    CR:
  2453.                         winEdit_BreakLine( pWiParams );
  2454.                         break;
  2455.  
  2456.                     default:
  2457.                         if( c_car >= ' ' )
  2458.                         {
  2459.                             winEdit_TypeCar( pWiParams, c_car );
  2460.                         }
  2461.                 }
  2462.         }
  2463.     }
  2464.     else if( c_car >= ' ' )
  2465.     {
  2466.         winEdit_TypeCar( pWiParams, c_car );
  2467.     }
  2468.  
  2469. }
  2470.  
  2471.  
  2472.  
  2473. /*
  2474.  * winEdit_MoveCsr(-)
  2475.  *
  2476.  * Purpose:
  2477.  * --------
  2478.  * D‚place le curseur
  2479.  * dans une fenˆtre d'‚dition texte
  2480.  *
  2481.  * Suggest:
  2482.  * --------
  2483.  * Ne pas tenter d'afficher le curseur s'il est trop loin de la 
  2484.  * partie visible de la fenˆtre (conversion pourrait le ramener o— il ne faut pas)
  2485.  * OPTIMIZE!
  2486.  *
  2487.  * History:
  2488.  * --------
  2489.  * 25.05.94: fplanque: Created
  2490.  * 26.05.94: extension des possibilit‚s
  2491.  * 30.05.94: la fenˆtre sepositionne avant d'afficher le nouveau curseur
  2492.  * 30.05.94: la fenˆtre se positionne aussi horizontalement
  2493.  * 01.06.94: R‚serve ‚cran avant de faire les op‚rations graphiques!!
  2494.  */
  2495. void    winEdit_MoveCsr(
  2496.             WIPARAMS *    pWiParams,    
  2497.             int            n_YMove,
  2498.             int            n_XMove )
  2499. {
  2500.     /*
  2501.      * Infos sur le texte … ‚diter:
  2502.      */
  2503.     TEXT_DRAWPAR * pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  2504.     long            nb_lignes    = pTextDrawPar -> pTextInfo -> nb_lignes;
  2505.     long            l_topline    = pTextDrawPar -> l_topline;
  2506.     TEXTLINE    *    pTextLine_edit = pTextDrawPar -> pTextLine_edit;    /* Ligne en cours d'‚dition; porte le curseur */
  2507.     long            l_LigneCsr    = pTextDrawPar -> l_LigneCsr;                /* Ligne ou se trouve le curseur [1...] (La ligne 0 n'est pas ‚ditable) */
  2508.     long            l_CurrLine    = l_LigneCsr;
  2509.     int            n_ColCsr        = pTextDrawPar -> n_ColCsr;                /* Colonne ou se trouve le curseur [0...nb_cars] si nb_cars:apres dernier caractŠre  */
  2510.     long            l_NewLigneCsr = l_LigneCsr + n_YMove;                    /* Nouvelle ligne curseur */
  2511.     int            n_NewColCsr = n_ColCsr + n_XMove;                    /* Nouvelle colonne curseur */
  2512.  
  2513.     /*
  2514.      * ---------------------
  2515.      * D‚placement vertical:
  2516.      * ---------------------
  2517.      */
  2518.     if( n_YMove )
  2519.     {
  2520.         /*
  2521.          * Contr“le si la nouvelle position Y est autoris‚e:
  2522.          */
  2523.         if( l_NewLigneCsr < 1)
  2524.         {
  2525.             l_NewLigneCsr = 1;    
  2526.         }
  2527.         else if( l_NewLigneCsr > nb_lignes )
  2528.         {
  2529.             l_NewLigneCsr = nb_lignes;
  2530.         }
  2531.     
  2532.         /*
  2533.          * D‚place la ligne courante:
  2534.          */
  2535.         while( l_CurrLine < nb_lignes )
  2536.         {
  2537.             l_CurrLine ++;
  2538.             pTextLine_edit = pTextLine_edit -> next;
  2539.         }
  2540.         while( l_CurrLine > l_NewLigneCsr )
  2541.         {
  2542.             l_CurrLine --;
  2543.             pTextLine_edit = pTextLine_edit -> prev;
  2544.         }
  2545.  
  2546.         /*
  2547.          * Contr“le si le curseur n'est pas sorti de la nouvelle ligne
  2548.          * par la droite:
  2549.          */
  2550.         if( n_NewColCsr > pTextLine_edit -> length )
  2551.         {    /*
  2552.              * SI on d‚borde … droite du texte:
  2553.              */
  2554.             n_NewColCsr = pTextLine_edit -> length;
  2555.         }        
  2556.     }    
  2557.  
  2558.  
  2559.     /*
  2560.      * -----------------------
  2561.      * D‚placement horizontal:
  2562.      * -----------------------
  2563.      */
  2564.     if( n_XMove )
  2565.     {
  2566.         /*
  2567.          * Contr“le si la position X est autoris‚e:
  2568.          */
  2569.         if( n_NewColCsr < 0)
  2570.         {    /*
  2571.              * SI on d‚borde … gauche du texte:
  2572.              */
  2573.             if( l_LigneCsr > 1 )
  2574.             {    /*
  2575.                  * remonte d'une ligne:
  2576.                  */
  2577.                 l_NewLigneCsr --;                                   /* Curseur sur ligne pr‚c‚dente */
  2578.                 pTextLine_edit = pTextLine_edit -> prev;    /* Nouvelle ligne … ‚diter */
  2579.                 n_NewColCsr = pTextLine_edit -> length;    /* Curseur en fin de ligne */
  2580.             }
  2581.             else
  2582.             {
  2583.                 n_NewColCsr = 0;    
  2584.             }
  2585.         }
  2586.         else if( n_NewColCsr > pTextLine_edit -> length )
  2587.         {    /*
  2588.              * SI on d‚borde … droite du texte:
  2589.              */
  2590.             if( l_LigneCsr < nb_lignes )
  2591.             {    /*
  2592.                  * descend d'une ligne:
  2593.                  */
  2594.                 l_NewLigneCsr ++;                                   /* Curseur sur ligne suivante< */
  2595.                 pTextLine_edit = pTextLine_edit -> next;    /* Nouvelle ligne … ‚diter */
  2596.                 n_NewColCsr = 0;                                    /* Curseur en d‚but de ligne */
  2597.             }
  2598.             else
  2599.             {
  2600.                 n_NewColCsr = pTextLine_edit -> length;
  2601.             }
  2602.         }
  2603.     }
  2604.  
  2605.  
  2606.     /*
  2607.      * Contr“le si la position … chang‚:
  2608.      */
  2609.     if( l_NewLigneCsr != l_LigneCsr || n_NewColCsr != n_ColCsr)
  2610.     {    /*
  2611.         * ==================
  2612.          * Position … chang‚:
  2613.         * ==================
  2614.          */
  2615.         int    n_workYHaut      = pWiParams -> work_y;
  2616.         int    n_workYBas      = get_workYBas( pWiParams );
  2617.         int    n_workXGauche = pWiParams -> work_x;
  2618.         int    n_workXDroit  = get_workXDroit( pWiParams );
  2619.         /*
  2620.          * Calcule coord pix Y sup‚rieure 
  2621.          * de la premiŠre ligne affich‚e (topline): 
  2622.          */
  2623.         int    line_h = pTextDrawPar -> n_cell_h;                        /* Hauteur d'une ligne en pixels */
  2624.         int    line_y = n_workYHaut                                         /* Pos Y sup de la ligne en cours d'affichage (init pourla topline) */
  2625.                             - line_h + (line_h /TEXT_VMARGINS_LINERATIO) /* Laisse un peu d'espace blanc */
  2626.                             - (int)((pWiParams -> seen_y) % line_h);        /* Tient compte du fait que la ligne peut ˆtre d‚cal‚e par rapport … son alignement vertical initial */
  2627.         /*
  2628.          * Calcule le 1er car … afficher … partir de la gauche
  2629.          * et sa coord pix X:
  2630.          */
  2631.         int    cell_w      = pTextDrawPar -> n_cell_w;                    /* Largeur d'un emplacement caractŠre en pixels */
  2632.         int    first_col = ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) / cell_w;
  2633.         int    line_x     = n_workXGauche                                    /* Position en pixels pour l'affichage des lignes de texte */
  2634.                                 - ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) % cell_w;    /* Laisse une marge de 4 pixels sur la gauche */
  2635.         /*
  2636.          * Nlles Coordonn‚es du curseur
  2637.          */
  2638.         int    n_CsrYHaut    = line_y + (int)(l_NewLigneCsr - l_topline) * line_h;                    
  2639.         int    n_CsrYBas    = n_CsrYHaut + line_h -1;
  2640.         int    n_CsrX        = line_x + (n_NewColCsr - first_col) * cell_w;
  2641.  
  2642.         /*
  2643.          * -----------------------------------------------
  2644.          * Effacement du curseur de son ancienne position:
  2645.          * -----------------------------------------------
  2646.          * Op‚rations graphiques sur le curseur:
  2647.          * vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  2648.          * R‚serve ‚cran: 
  2649.          */
  2650.         start_WINDRAW( NULL );
  2651.     
  2652.         /*
  2653.          * Clipping sur la zone de travail:
  2654.          */
  2655.         G_pxyarray[0] = n_workXGauche;
  2656.         G_pxyarray[1] = n_workYHaut;
  2657.         G_pxyarray[2] = n_workXDroit;
  2658.         G_pxyarray[3] = n_workYBas;
  2659.         vs_clip( G_ws_handle, YES1, G_pxyarray );    /* Clipping pour text */
  2660.     
  2661.         /*
  2662.          * Fixe attributs de remplissage:
  2663.          */
  2664.         vsf_interior( G_ws_handle, FIS_SOLID );        /* remplissage: PLEIN(couleur courante) */
  2665.         vswr_mode( G_ws_handle, MD_XOR );
  2666.     
  2667.         /*
  2668.          * Efface le curseur de l'ancienne position:
  2669.          */
  2670.         G_pxyarray[0] = line_x + (n_ColCsr - first_col) * cell_w;    /* Coord X du curseur */
  2671.         G_pxyarray[1] = line_y + (int)(l_LigneCsr - l_topline) * line_h;    /* Coord Y de la ligne */
  2672.         G_pxyarray[2] = G_pxyarray[0] + CURSOR_WIDTH -1;                /* Coord X droite du curseur */
  2673.         G_pxyarray[3] = G_pxyarray[1] + line_h -1;    /* Coord Y basse du curseur */
  2674.         vr_recfl( G_ws_handle, G_pxyarray );     
  2675.     
  2676.         /*
  2677.          * Remet les attributs de remplissage … leurs valeurs par d‚faut:
  2678.          */
  2679.         vswr_mode( G_ws_handle, MD_REPLACE );
  2680.         vsf_interior( G_ws_handle, FIS_HOLLOW );        /* remplissage: VIDE(blanc) */
  2681.     
  2682.         /*
  2683.          * Supprime rectangle de clipping:
  2684.          */
  2685.          vs_clip( G_ws_handle, NO0, G_pxyarray );        /* Clipping OFF! */
  2686.         
  2687.         /*
  2688.          * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  2689.          * rend le contr“le de l'‚cran: 
  2690.          */
  2691.         end_WINDRAW();
  2692.         
  2693.         /*
  2694.          * Il n'y a TEMPORAIREMENT plus de curseur:
  2695.          * C'est important pour les routines de redraw invoqu‚es lors
  2696.          * du d‚pacement de la fenˆtre vers le curseur
  2697.          */
  2698.         pTextDrawPar -> pTextLine_edit = NULL;
  2699.  
  2700.  
  2701.         /*
  2702.          * ------------------------------------------------------------
  2703.          * D‚placement de la fenˆtre vers la nouvelle position curseur:
  2704.          * ------------------------------------------------------------
  2705.          * Contr“le de la position verticale:
  2706.          */
  2707.         if( n_CsrYHaut < n_workYHaut )
  2708.         {    /* 
  2709.              * Le curseur est au dessus de la partie visible
  2710.              * ou seulement partiellement affich‚:
  2711.              */
  2712.             unsigned long    ul_new_VertTextPos = l_max ( 0,
  2713.                                                         (l_NewLigneCsr - 1) * line_h );
  2714.             /*
  2715.              * D‚place la vue: 
  2716.              */
  2717.             move_TextView_vert( pWiParams, ul_new_VertTextPos );
  2718.         }
  2719.         else if( n_CsrYBas > n_workYBas )
  2720.         {    /* 
  2721.              * Le curseur est au dessous de la partie visible
  2722.              * ou seulement partiellement affich‚:
  2723.              */
  2724.             unsigned long    ul_new_VertTextPos = l_min ( pWiParams -> total_h - pWiParams -> seen_h,
  2725.                                  (l_NewLigneCsr + 1) * line_h 
  2726.                                  - pWiParams -> seen_h
  2727.                                  - (line_h/TEXT_VMARGINS_LINERATIO + TEXT_VBOTTOM_COMPENSATE) );
  2728.             /*
  2729.              * D‚place la vue: 
  2730.              */
  2731.             move_TextView_vert( pWiParams, ul_new_VertTextPos );
  2732.         }
  2733.  
  2734.  
  2735.         /*
  2736.          * Contr“le de la position horizontale:
  2737.          */
  2738.         if( n_CsrX < n_workXGauche )
  2739.         {    /* 
  2740.              * Le car concern‚ par le curseur est … gauche de la partie visible
  2741.              * ou seulement partiellement affich‚:
  2742.              */
  2743.             unsigned long    ul_new_HorizTextPos =
  2744.                                     l_max ( 0, n_NewColCsr * cell_w );
  2745.             /*
  2746.              * D‚place la vue: 
  2747.              */
  2748.             move_TextView_horiz( pWiParams, ul_new_HorizTextPos );
  2749.         }
  2750.         else if( n_CsrX + cell_w > n_workXDroit )
  2751.         {    /* 
  2752.              * En fait c'est n_CsrX + cell_w -1 mais bon...
  2753.              * Le car sous curseur est … droite de la partie visible
  2754.              * ou seulement partiellement affich‚:
  2755.              */
  2756.             unsigned long    ul_new_HorizTextPos = 
  2757.                                 l_min ( pWiParams -> total_w - pWiParams -> seen_w,
  2758.                                  TEXT_HMARGINS_WIDTH + (n_NewColCsr + 1) * cell_w 
  2759.                                  - pWiParams -> seen_w );
  2760.             /*
  2761.              * D‚place la vue: 
  2762.              */
  2763.             move_TextView_horiz( pWiParams, ul_new_HorizTextPos );
  2764.         }
  2765.  
  2766.  
  2767.         /*
  2768.          * Mise … jour des variables qui auraient pu changer
  2769.          * lors du d‚placement de la fenˆtre sur le texte
  2770.          */
  2771.         l_topline    = pTextDrawPar -> l_topline;
  2772.         line_y         = n_workYHaut                                         /* Pos Y sup de la ligne en cours d'affichage (init pourla topline) */
  2773.                             - line_h + (line_h /TEXT_VMARGINS_LINERATIO) /* Laisse un peu d'espace blanc */
  2774.                             - (int)((pWiParams -> seen_y) % line_h);        /* Tient compte du fait que la ligne peut ˆtre d‚cal‚e par rapport … son alignement vertical initial */
  2775.         first_col    = ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) / cell_w;
  2776.         line_x        = n_workXGauche                                    /* Position en pixels pour l'affichage des lignes de texte */
  2777.                                 - ((int)(pWiParams -> seen_x) - TEXT_HMARGINS_WIDTH) % cell_w;    /* Laisse une marge de 4 pixels sur la gauche */
  2778.         n_CsrYHaut    = line_y + (int)(l_NewLigneCsr - l_topline) * line_h;    /* Coord Y de la ligne */
  2779.         n_CsrYBas    = n_CsrYHaut + line_h -1;
  2780.         n_CsrX        = line_x + (n_NewColCsr - first_col) * cell_w;
  2781.  
  2782.  
  2783.         /* 
  2784.          * --------------------------------------------
  2785.          * R‚affiche le curseur … sa nouvelle position:
  2786.          * --------------------------------------------
  2787.          * Op‚rations graphiques sur le curseur:
  2788.          * vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  2789.          * R‚serve ‚cran: 
  2790.          */
  2791.         start_WINDRAW( NULL );
  2792.  
  2793.         /* 
  2794.          * Clipping sur la zone de travail:
  2795.          */
  2796.         G_pxyarray[0] = n_workXGauche;
  2797.         G_pxyarray[1] = n_workYHaut;
  2798.         G_pxyarray[2] = n_workXDroit;
  2799.         G_pxyarray[3] = n_workYBas;
  2800.         vs_clip( G_ws_handle, YES1, G_pxyarray );    /* Clipping pour text */
  2801.     
  2802.         /*
  2803.          * Fixe attributs de remplissage:
  2804.          */
  2805.         vsf_interior( G_ws_handle, FIS_SOLID );        /* remplissage: PLEIN(couleur courante) */
  2806.         vswr_mode( G_ws_handle, MD_XOR );
  2807.     
  2808.         /*
  2809.          * R‚affiche le curseur … la nouvelle position:
  2810.          */
  2811.         G_pxyarray[0] = n_CsrX;                    /* Coord X du curseur */
  2812.         G_pxyarray[1] = n_CsrYHaut;            /* Coord Y de la ligne */
  2813.         G_pxyarray[2] = n_CsrX + CURSOR_WIDTH - 1;            /* Coord X droite du curseur */
  2814.         G_pxyarray[3] = n_CsrYBas;                /* Coord Y basse du curseur */
  2815.         vr_recfl( G_ws_handle, G_pxyarray );     
  2816.     
  2817.         /*
  2818.          * Remet les attributs de remplissage … leurs valeurs par d‚faut:
  2819.          */
  2820.         vswr_mode( G_ws_handle, MD_REPLACE );
  2821.         vsf_interior( G_ws_handle, FIS_HOLLOW );        /* remplissage: VIDE(blanc) */
  2822.     
  2823.         /*
  2824.          * Supprime rectangle de clipping:
  2825.          */
  2826.          vs_clip( G_ws_handle, NO0, G_pxyarray );        /* Clipping OFF! */
  2827.  
  2828.         /*
  2829.          * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  2830.          * rend le contr“le de l'‚cran: 
  2831.          */
  2832.         end_WINDRAW();
  2833.  
  2834.         /*
  2835.          * -----------------------------------
  2836.          * Sauve nouvelle position du curseur:
  2837.          * -----------------------------------
  2838.          */ 
  2839.         pTextDrawPar -> pTextLine_edit = pTextLine_edit;
  2840.         pTextDrawPar -> l_LigneCsr = l_NewLigneCsr;
  2841.         pTextDrawPar -> n_ColCsr = n_NewColCsr;
  2842.     }
  2843. }
  2844.  
  2845.  
  2846.  
  2847.  
  2848. /*
  2849.  * winEdit_TypeCar(-)
  2850.  *
  2851.  * Purpose:
  2852.  * --------
  2853.  * Ajoute un caractŠre dans une fenˆtre d'‚dition texte.
  2854.  *
  2855.  * Suggest:
  2856.  * --------
  2857.  * ATTENTION … ne pas d‚passer la limite en largeur!
  2858.  *
  2859.  * History:
  2860.  * --------
  2861.  * 30.05.94: fplanque: Created
  2862.  * 31.05.94: Correction bug sur r‚allocation du buffer
  2863.  * 04.07.94: Impossible de taper plus que longueur maximale autoris‚e
  2864.  * 05.07.94: D‚place vue vers curseur avant d'‚crire
  2865.  */
  2866. void    winEdit_TypeCar(
  2867.             WIPARAMS *    pWiParams,    
  2868.             char            c_car )
  2869. {
  2870.     TEXT_DRAWPAR *    pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  2871.     /*
  2872.      * Colonne du curseur;
  2873.      */
  2874.     int                n_Pos = pTextDrawPar -> n_ColCsr;
  2875.     /* 
  2876.      * Ligne en cours d'‚dition; porte le curseur:
  2877.      */
  2878.     TEXTLINE         *    pTextLine_edit = pTextDrawPar -> pTextLine_edit;
  2879.     /*
  2880.      * Longueur de cette ligne (\0 non compris):
  2881.      */
  2882.     int                n_length = pTextLine_edit -> length;        
  2883.  
  2884.     /*
  2885.      * ---------------------------------------
  2886.      * D‚place la vue courante sur le curseur:
  2887.      * ---------------------------------------
  2888.      */
  2889.     move_TextViewToPos( pWiParams, pTextDrawPar -> l_LigneCsr, 1, n_Pos, 8 );
  2890.     
  2891.  
  2892.     /*
  2893.      * Contr“le longueur ligne:
  2894.      */
  2895.     if( n_length >= G_def_text_width )
  2896.     {    /*
  2897.          * Si longueur ligne max atteinte:
  2898.          * ( '>' ne devrait JAMAIS se produire)
  2899.          */
  2900.         ping();
  2901.         return;
  2902.     }
  2903.  
  2904.     /*
  2905.      * Ajoute caractŠre ds texte:
  2906.      */
  2907.     textEdit_addChar( pTextLine_edit, n_Pos, c_car, G_def_text_width );
  2908.  
  2909.  
  2910.     /*
  2911.      * Curseur avance:
  2912.      */
  2913.     pTextDrawPar -> n_ColCsr = n_Pos + 1;
  2914.      
  2915.     /*
  2916.      * R‚affiche la fin de ligne:
  2917.      * Cel… … pour effet secondaire d'‚craser le curseur actuel
  2918.      * et de le r‚afficher … sa nouvelle position:
  2919.      */
  2920.     start_WINDRAW( NULL );
  2921.     redraw_textline( pWiParams, pTextLine_edit, pTextDrawPar -> l_LigneCsr, n_Pos, NIL_1 );
  2922.     end_WINDRAW();
  2923.     
  2924.     /*
  2925.      * Signale … la fenˆtre que son contenu a ‚t‚ modifi‚:
  2926.      */
  2927.     Wnd_SetModified( pWiParams );
  2928.     
  2929. }
  2930.  
  2931.  
  2932.  
  2933. /*
  2934.  * winEdit_DelCar(-)
  2935.  *
  2936.  * Purpose:
  2937.  * --------
  2938.  * Efface un caractŠre dans une fenˆtre d'‚dition texte.
  2939.  * aprŠs apui sur backspace ou delete
  2940.  *
  2941.  * Algorythm:
  2942.  * ----------  
  2943.  * Backspace est trait‚ comme delete sauf que le curseur est d‚plac‚ en
  2944.  * arriŠre au pr‚alable.
  2945.  *
  2946.  * Suggest:
  2947.  * --------
  2948.  * Groupper tous les bouts de codes de scrolling en une seule proc‚dure
  2949.  *
  2950.  * History:
  2951.  * --------
  2952.  * 01.06.94: fplanque: Created base on _TypeCar()
  2953.  * 01.07.94: D‚but gestion backspace
  2954.  * 04.07.94: Possibilit‚ de regroupper 2 lignes avec Delete
  2955.  * 05.07.94: Backspace peut regroupper lignes
  2956.  * 05.07.94: Correction bug d'effacement derniŠre ligne lors d'un regrouppement sur derniŠre ligne
  2957.  * 01.08.94: Ajout‚ 1 pixel en hauteur au scroll... ‡a marche mais je sais pas pourkoi!?
  2958.  * 03.08.94: En fait, la correction du 01.08 ‚tait mauvaise: enlev‚: il fallait v‚rifier que la zone de scroll ‚tait suffisament haute pour le d‚placement envisag‚!
  2959.  * 20.08.94: Modifi‚ m‚thode de redraw de la ligne:
  2960.  * 24.08.94; ajout‚ traitement du flag continued
  2961.  */
  2962. void    winEdit_DelCar(                    /* Out: rien */
  2963.             WIPARAMS *    pWiParams,        /* In: ParamŠtres fenˆtre */
  2964.             int            b_backspace )    /* In: True si backspace */
  2965. {
  2966.     TEXT_DRAWPAR *    pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  2967.     TEXTINFO         * pTextInfo = pTextDrawPar -> pTextInfo;
  2968.  
  2969.     /*
  2970.      * Colonne du curseur;
  2971.      */
  2972.     int                n_Pos = pTextDrawPar -> n_ColCsr;
  2973.     /* 
  2974.      * Ligne en cours d'‚dition; porte le curseur:
  2975.      */
  2976.     long                l_editLine = pTextDrawPar -> l_LigneCsr;
  2977.     TEXTLINE         *    pTextLine_edit = pTextDrawPar -> pTextLine_edit;
  2978.     /*
  2979.      * Texte & Longueur de cette ligne (\0 non compris):
  2980.      */
  2981.     char             *    pS_text;    
  2982.     int                n_length;        
  2983.  
  2984.     /*
  2985.      * ---------------------------------
  2986.      * Contr“le si on fait un backspace:
  2987.      * ---------------------------------
  2988.      */
  2989.     if( b_backspace )
  2990.     {    /*
  2991.          * D‚place le curseur avant de proc‚der … un DELETE normal:
  2992.          */
  2993.         if( n_Pos > 0 )
  2994.         {    /*
  2995.              * On va vers la gauche:
  2996.              */
  2997.             pTextDrawPar -> n_ColCsr = --n_Pos;
  2998.         }
  2999.         else
  3000.         {    /*
  3001.              * Il faut passer … la ligne pr‚c‚dente:
  3002.              */
  3003.             if( l_editLine == 1 )
  3004.             {    /*
  3005.                  * Si on ‚tait au d‚but du texte:
  3006.                  * IMPOSSIBLE de faire un backspace:
  3007.                  */
  3008.                 ping();
  3009.                 return;
  3010.             }
  3011.  
  3012.             /*
  3013.              * Passe … la ligne pr‚c‚dente:
  3014.              */
  3015.             pTextDrawPar -> l_LigneCsr         = --l_editLine;
  3016.             pTextDrawPar -> pTextLine_edit =    pTextLine_edit = pTextLine_edit -> prev;
  3017.             pTextDrawPar -> n_ColCsr         = n_Pos             = pTextLine_edit -> length;
  3018.         }
  3019.     }    /* fin if backspace */
  3020.  
  3021.  
  3022.     /*
  3023.      * ---------------------------------------
  3024.      * D‚place la vue courante sur le curseur:
  3025.      * ---------------------------------------
  3026.      */
  3027.     move_TextViewToPos( pWiParams, l_editLine, 1, n_Pos, 8 );
  3028.     
  3029.     /*
  3030.      * Texte & Longueur de cette ligne (\0 non compris):
  3031.      */
  3032.     pS_text = pTextLine_edit -> text;    
  3033.     n_length = pTextLine_edit -> length;
  3034.  
  3035.     /*
  3036.      * Contr“le s'il y a quelque chose … effacer:
  3037.      */
  3038.     if( n_Pos < n_length && n_length > 0 )
  3039.     {    /*
  3040.          * =================================
  3041.          * Si on peut effacer DANS la ligne:
  3042.          * =================================
  3043.          * Efface le caractŠre:
  3044.          */
  3045.         textEdit_delChar( pTextLine_edit, n_Pos );
  3046.  
  3047.         /*
  3048.          * R‚affiche la fin de ligne:
  3049.          * Cel… … pour effet secondaire d'‚craser le curseur actuel
  3050.          * et de le r‚afficher … sa nouvelle position:
  3051.          */
  3052.         start_WINDRAW( NULL );
  3053.         redraw_textline(    pWiParams,
  3054.                                 pTextLine_edit, 
  3055.                                 pTextDrawPar -> l_LigneCsr, 
  3056.                                 n_Pos,
  3057.                                 ( (pTextLine_edit -> length) +1 - n_Pos) * (pTextDrawPar -> n_cell_w) + CURSOR_WIDTH );
  3058.         end_WINDRAW();
  3059.  
  3060.     }    
  3061.     else
  3062.     {    /*
  3063.          * ========================================================= 
  3064.          * On est en fin de ligne:
  3065.          * On va devoir regroupper cette ligne avec la suivante:
  3066.          * ========================================================= 
  3067.          * Variables Ligne suivante:
  3068.          */
  3069.         TEXTLINE    *    pTextLine_next = pTextLine_edit -> next;
  3070.         
  3071.         if( pTextLine_next == NULL )
  3072.         {    /*
  3073.              * Pas de ligne suivante:
  3074.              * IMPOSSIBLE de faire un DELETE:
  3075.              */
  3076.             ping();
  3077.             return;
  3078.         }
  3079.  
  3080.         {
  3081.         int            n_length_next = pTextLine_next -> length;
  3082.         /*
  3083.          * Longueur l qu'on va utiliser: 
  3084.          * 0 < l < Place_Libre
  3085.          */
  3086.         int    n_usedLength_next    = 0;
  3087.     
  3088.         /*
  3089.          * Coordonn‚es de la zone texte:
  3090.          */
  3091.         int    n_workXGauche = pWiParams -> work_x;
  3092.         int    n_workXDroit  = get_workXDroit( pWiParams );
  3093.         int    n_workYHaut      = pWiParams -> work_y;
  3094.         int    n_workYBas      = get_workYBas( pWiParams );
  3095.         /*
  3096.          * Calcule coord pix Y sup‚rieure 
  3097.          * de la premiŠre ligne affich‚e (topline): 
  3098.          */
  3099.         int    line_h = pTextDrawPar -> n_cell_h;                        /* Hauteur d'une ligne en pixels */
  3100.         int    line_y = n_workYHaut                                         /* Pos Y sup de la ligne en cours d'affichage (init pourla topline) */
  3101.                             - line_h + (line_h /TEXT_VMARGINS_LINERATIO) /* Laisse un peu d'espace blanc */
  3102.                             - (int)((pWiParams -> seen_y) % line_h);        /* Tient compte du fait que la ligne peut ˆtre d‚cal‚e par rapport … son alignement vertical initial */
  3103.         /*
  3104.          * Nlles Coordonn‚es du curseur
  3105.          */
  3106.         int    n_YHautNextLine; /*    = line_y + (int)(l_editLine - pTextDrawPar->l_topline) * line_h;                    
  3107.                                         /*    int    n_CsrYBas    = n_CsrYHaut + line_h -1; */
  3108.  
  3109.         BOOL    b_noOverlap;        /* Indique si fenˆtre est overlapp‚e lors du redraw */
  3110.     
  3111.         if( n_length_next > 0 )
  3112.         {    /*
  3113.              * Si la ligne suivante n'est pas vide:
  3114.              */
  3115.             int            n_newBufSize;
  3116.             
  3117.             /*
  3118.              * Longueur l qu'on va utiliser: 
  3119.              * 0 < l < Place_Libre
  3120.              */
  3121.             n_usedLength_next    = min( G_def_text_width - n_length, n_length_next );
  3122.             
  3123.             /*
  3124.              * Nouvelle ligne:
  3125.              */
  3126.             n_newBufSize = n_length + n_usedLength_next;
  3127.  
  3128.             /*
  3129.               * Cr‚e nouvelle ligne:
  3130.               */
  3131.             pS_text = realloc_String( pS_text, n_newBufSize + 1 );
  3132.             memcpy( &(pS_text[ n_length ]), pTextLine_next -> text, n_usedLength_next );
  3133.             pS_text[ n_newBufSize ] = '\0';            
  3134.             
  3135.             /*
  3136.              * IntŠgre nouvelle ligne au texte:
  3137.              */
  3138.             pTextLine_edit -> info1.bufsize    = n_newBufSize;
  3139.             pTextLine_edit -> length    = n_newBufSize;
  3140.             pTextLine_edit -> text        = pS_text;
  3141.  
  3142.             /*
  3143.              * V‚rifie si l'ancienne ligne peut ˆtre ‚ffac‚e:
  3144.              */
  3145.             if( n_usedLength_next >= n_length_next )
  3146.             {
  3147.                 /*
  3148.                  * Si l'ancienne ligne ‚tat une fin de paragraphe: idem
  3149.                  * sinon continued...
  3150.                  */
  3151.                 pTextLine_edit -> info1.continued = pTextLine_next -> info1.continued;
  3152.  
  3153.                 /* 
  3154.                  * Toute la ligne a ‚t‚ transf‚r‚e vers le haut:
  3155.                  * Efface l'ancienne ligne:
  3156.                  */
  3157.                 delete_line( pTextLine_next, pTextInfo );
  3158.                 /*
  3159.                  * Calcule nlle taille du texte: 
  3160.                  */
  3161.                 calc_textSizeH( pWiParams );
  3162.  
  3163.             }
  3164.             else
  3165.             {
  3166.                 /* PROVISOIRE: Sinon, elle reste en place... */
  3167.     
  3168.                 /*
  3169.                  * La ligne courante se prolonge...
  3170.                  */
  3171.                 pTextLine_edit -> info1.continued = TRUE_1;
  3172.  
  3173.             }
  3174.         }
  3175.         else
  3176.         {    /*
  3177.              * La ligne suivante est vide:
  3178.              * Tout ce qu'on a … faire, c'est l'effacer:
  3179.              */
  3180.             delete_line( pTextLine_next, pTextInfo );
  3181.             /*
  3182.              * Calcule nlle taille du texte: 
  3183.              */
  3184.             calc_textSizeH( pWiParams );
  3185.         }
  3186.             
  3187.         /*
  3188.          * D‚but des op‚rations graphiques:
  3189.          * vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  3190.          * R‚serve ‚cran: 
  3191.          */
  3192.         b_noOverlap = start_WINDRAW( pWiParams );
  3193.     
  3194.         /* 
  3195.          * --------------------------
  3196.          * R‚affiche la fin de la ligne en ‚dition:
  3197.          * --------------------------
  3198.          */
  3199.         redraw_textline(    pWiParams, pTextLine_edit, 
  3200.                                 l_editLine, n_Pos, 
  3201.                                 n_usedLength_next * ( pTextDrawPar -> n_cell_w ) );
  3202.         
  3203.         /*
  3204.          * -------------------------------
  3205.          * D‚place les lignes qui suivent:
  3206.          * -------------------------------
  3207.          */
  3208.         n_YHautNextLine = line_y + 
  3209.                     (int)(l_editLine - pTextDrawPar->l_topline + 1) * line_h;
  3210.     
  3211.         if( b_noOverlap == FALSE0 
  3212.             || n_workYBas - n_YHautNextLine <= line_h
  3213.             || pTextLine_edit == pTextInfo -> lastline )
  3214.         {    /*
  3215.              * - La fenˆtre n'est pas en un seul bloc
  3216.              *     ou
  3217.              * - L'espace de scroll est plus petit qu'une ligne!
  3218.              *   -> comme on deplace de la
  3219.              *      hauteur d'une ligne: on n'a rien a scroller!
  3220.              *         ou
  3221.              * - On vient de supprimer la derniŠre ligne
  3222.              *
  3223.              * => impossible de scroller: 
  3224.              * Affiche toutes les lignes suivant celle qu'on coupe: 
  3225.              */
  3226.             redraw( pWiParams, n_workXGauche, n_YHautNextLine,
  3227.                          pWiParams -> seen_w, n_workYBas - n_YHautNextLine + 1 , CTRL_OK );
  3228.         }
  3229.         else
  3230.         {    /* 
  3231.              * Si la fenˆtre est au top:
  3232.              * et qu'on est pas sur la derniŠre ligne:
  3233.              * on peut faire scroller la suite du texte:
  3234.              */
  3235.             
  3236.             graf_mouse( M_OFF, NULL);            /* Efface le ptr souris */
  3237.  
  3238.             /* 
  3239.              * Coordonn‚es source, destination: 
  3240.              */
  3241.             G_pxyarray[0] = n_workXGauche;             /* Coord source */
  3242.             G_pxyarray[1] = n_YHautNextLine + line_h;
  3243.             G_pxyarray[2] = n_workXDroit;
  3244.             G_pxyarray[3] = n_workYBas;
  3245.  
  3246.             G_pxyarray[4] = n_workXGauche;            /* Coord destination */
  3247.             G_pxyarray[5] = n_YHautNextLine;
  3248.             G_pxyarray[6] = n_workXDroit;
  3249.             G_pxyarray[7] = n_workYBas - line_h;
  3250.  
  3251.             /* 
  3252.              * D‚placement d'un bloc vers le HAUT sur l'‚cran logique: 
  3253.              */
  3254.             vro_cpyfm( G_ws_handle, S_ONLY, G_pxyarray,
  3255.                           &G_plogMFDB, &G_plogMFDB);
  3256.         
  3257.         
  3258.             graf_mouse( M_ON, 0);                /* Affiche le ptr souris */
  3259.  
  3260.  
  3261.             /*
  3262.              * Affiche ce qui n'a pas encore ‚t‚ trait‚ par scroll: 
  3263.              */
  3264.             redraw( pWiParams, 
  3265.                         n_workXGauche, 
  3266.                         n_workYBas - line_h + 1 ,
  3267.                         pWiParams -> seen_w, 
  3268.                         line_h ,
  3269.                         CTRL_OK );
  3270.  
  3271.         }
  3272.     
  3273.     
  3274.         /*
  3275.          * Fin des op‚rations graphiques:
  3276.          * LibŠre l'‚cran:
  3277.          */
  3278.         end_WINDRAW();
  3279.  
  3280.         /*
  3281.          * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  3282.          */
  3283.         
  3284.         /*
  3285.          * Fixe nlle taille et position ascenseur: 
  3286.          */
  3287.         set_slider_h( pWiParams );            /* Fix taille slider vertical */
  3288.         set_slider_y( pWiParams );            /* Fix position slider vertical */
  3289.         }
  3290.     }        
  3291.     
  3292.     /*
  3293.      * Signale … la fenˆtre que son contenu a ‚t‚ modifi‚:
  3294.      */
  3295.     Wnd_SetModified( pWiParams );
  3296. }
  3297.  
  3298.  
  3299.  
  3300. /*
  3301.  * winEdit_BreakLine(-)
  3302.  *
  3303.  * Purpose:
  3304.  * --------
  3305.  * Coupe une ligne … l'endroit du curseur suite … pression sur return.
  3306.  *
  3307.  * Suggest:
  3308.  * --------
  3309.  * ComplŠtement inachev‚, plein de bugs!
  3310.  * scroll du bas de la fenˆtre
  3311.  *
  3312.  * History:
  3313.  * --------
  3314.  * 13.06.94: fplanque: Created base on _DelCar()
  3315.  * 14.06.94: fplanque: D‚place fenˆtre sur curseur avant d'agir.
  3316.  * 14.06.94: aprŠs insertion: maj ascenseur vert & redraw lignes suivantes
  3317.  * 17.06.94: impl‚mentation scrolling
  3318.  * 18.06.94: optimisation graphique + gestion des effacements/redraws curseur
  3319.  * 08.01.95: corrig‚ bug lorsqu'on breake en bas de la fenˆtre
  3320.  */
  3321. void    winEdit_BreakLine(
  3322.             WIPARAMS *    pWiParams )
  3323. {
  3324.     TEXT_DRAWPAR *    pTextDrawPar = pWiParams -> draw_ptr.pTextDrawPar;
  3325.     TEXTINFO         * pTextInfo = pTextDrawPar -> pTextInfo;
  3326.     /*
  3327.      * Colonne du curseur:
  3328.      */
  3329.     int                n_Pos = pTextDrawPar -> n_ColCsr;
  3330.     /* 
  3331.      * Ligne en cours d'‚dition; porte le curseur:
  3332.      */
  3333.     long                l_editLine = pTextDrawPar -> l_LigneCsr;
  3334.     TEXTLINE         *    pTextLine_edit = pTextDrawPar -> pTextLine_edit;
  3335.     char             *    pS_text = pTextLine_edit -> text;    
  3336.     char             * pS_CarPos = &( pS_text[ n_Pos ] );
  3337.     /*
  3338.      * Nouvelle ligne:
  3339.      */
  3340.     TEXTLINE        * pTextLine_new;
  3341.     char            * pS_newText;
  3342.  
  3343.     /*
  3344.      * Coordonn‚es de la zone texte:
  3345.      */
  3346.     int    n_workXGauche = pWiParams -> work_x;
  3347.     int    n_workXDroit  = get_workXDroit( pWiParams );
  3348.     int    n_workYHaut      = pWiParams -> work_y;
  3349.     int    n_workYBas      = get_workYBas( pWiParams );
  3350.     /*
  3351.      * Calcule coord pix Y sup‚rieure 
  3352.      * de la premiŠre ligne affich‚e (topline): 
  3353.      */
  3354.     int    line_h = pTextDrawPar -> n_cell_h;                        /* Hauteur d'une ligne en pixels */
  3355.     int    line_y;
  3356.     
  3357.     int    n_CsrYHaut;
  3358.  
  3359.     /*
  3360.      * Affichages:
  3361.      */    
  3362.     int    n_eraseLength;        /* Longueur de ligne … effacer */
  3363.     BOOL    b_noOverlap;        /* Indique si fenˆtre est overlapp‚e lors du redraw */
  3364.     
  3365.  
  3366.     /*
  3367.      * -----------------------------------------
  3368.      * Place la fenˆtre sur l'endroit du curseur
  3369.      * Note: le curseur va descendre d'une ligne au cours du break.
  3370.      *       il ne doit donc pas ˆtre sur la ligne du bas de la fenˆtre
  3371.      *       sinon il faudrait RE-SCROLLER!
  3372.      * -----------------------------------------
  3373.      */
  3374.     move_TextViewToPos( pWiParams, l_editLine, 2, 0, 1 );
  3375.  
  3376.     /*
  3377.      * ------------------------------------
  3378.      * Contr“le si la ligne n'est pas vide:
  3379.      * ------------------------------------
  3380.      */
  3381.     if( pS_text != NULL )
  3382.     {    /*
  3383.          * S'il y a du texte … casser:
  3384.          */        
  3385.         pS_newText = STRDUP( pS_CarPos );    /* Duplique fin de ligne */
  3386.         *pS_CarPos = '\0';                        /* Coupe la ligne d'origine */
  3387.         n_eraseLength = pTextLine_edit -> length - n_Pos;    /* Longueur … effacer */
  3388.         pTextLine_edit -> length = n_Pos;     /* Nouvelle longueur de ligne */
  3389.     }    
  3390.     else
  3391.     {    /*
  3392.          * Rien … couper!
  3393.          * On cr‚e donc simplement une ligne vide.
  3394.          */
  3395.         pS_newText = NULL;
  3396.         n_eraseLength = 0;        /* Longueur … effacer */
  3397.     }
  3398.  
  3399.     
  3400.     /*
  3401.      * Cr‚ation/Insertion d'une nouvelle ligne;
  3402.      */
  3403.     pTextLine_new = insert_line( pTextLine_edit, pS_newText, NIL, pTextInfo );
  3404.     /*
  3405.      * Calcule nlle taille du texte: 
  3406.      */
  3407.     calc_textSizeH( pWiParams );
  3408.  
  3409.  
  3410.     /*
  3411.      * ----------------
  3412.      * D‚place curseur:
  3413.      * ----------------
  3414.      */
  3415.     pTextDrawPar -> pTextLine_edit = pTextLine_new;
  3416.     pTextDrawPar -> l_LigneCsr = ++l_editLine;
  3417.     pTextDrawPar -> n_ColCsr = 0;
  3418.  
  3419.  
  3420.     /*
  3421.      * D‚but des op‚rations graphiques:
  3422.      * vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  3423.      * R‚serve ‚cran: 
  3424.      */
  3425.     b_noOverlap = start_WINDRAW( pWiParams );
  3426.  
  3427.     /* 
  3428.      * --------------------------
  3429.      * Efface la fin de l'ancienne ligne en ‚dition:
  3430.      * --------------------------
  3431.      * R‚affiche la fin de ligne:
  3432.      * Cela a pour effet secondaire d'‚craser le curseur actuel
  3433.      * et de le r‚afficher … sa nouvelle position:
  3434.      */
  3435.     redraw_textline(    pWiParams, pTextLine_edit, 
  3436.                             l_editLine - 1, n_Pos,
  3437.                             n_eraseLength * ( pTextDrawPar -> n_cell_w )  );
  3438.     
  3439.  
  3440.     /*
  3441.      * -------------------------------
  3442.      * D‚place les lignes qui suivent:
  3443.      * -------------------------------
  3444.      * Nouvelles Positions texte & curseur:
  3445.      */
  3446.     line_y = n_workYHaut                                         /* Pos Y sup de la ligne en cours d'affichage (init pourla topline) */
  3447.                         - line_h + (line_h /TEXT_VMARGINS_LINERATIO) /* Laisse un peu d'espace blanc */
  3448.                         - (int)((pWiParams -> seen_y) % line_h);        /* Tient compte du fait que la ligne peut ˆtre d‚cal‚e par rapport … son alignement vertical initial */
  3449.     n_CsrYHaut    = line_y + 
  3450.                         (int)(l_editLine - pTextDrawPar->l_topline) * line_h;
  3451.  
  3452.     if( b_noOverlap == FALSE0 )
  3453.     {    /*
  3454.          * La fenˆtre n'est pas en un seul bloc: 
  3455.          * impossible de scroller: 
  3456.          * Affiche toutes les lignes suivant celle qu'on coupe: 
  3457.          */
  3458.         redraw( pWiParams, n_workXGauche, n_CsrYHaut,
  3459.                      pWiParams -> seen_w, n_workYBas - n_CsrYHaut + 1 , CTRL_OK );
  3460.     }
  3461.     else
  3462.     {    /* 
  3463.          * Si la fenˆtre est au top: on peut la faire scroller: 
  3464.          */
  3465.         int    n_min_length = 0;        /* Par d‚faut: il n'y a rien … ‚craser en dessous... */
  3466.          
  3467.         /* 
  3468.          * Teste s'il y a quelque chose … scroller:
  3469.          */
  3470.         if( pTextLine_new != pTextInfo -> lastline )
  3471.         {    /*
  3472.              * On ne vient pas de cr‚er la derniŠre ligne,
  3473.              * donc il y a d'autres lignes en dessous, qu'il faut 
  3474.              * maintenant scroller: 
  3475.              */
  3476.             if( n_CsrYHaut + line_h <= n_workYBas ) 
  3477.             {    /*
  3478.                  * En plus, il y a de la place pour scroller:
  3479.                  */
  3480.                 
  3481.                 graf_mouse( M_OFF, NULL);            /* Efface le ptr souris */
  3482.     
  3483.                 /* 
  3484.                  * Coordonn‚es source, destination: 
  3485.                  */
  3486.                 G_pxyarray[0] = n_workXGauche;             /* Coord source */
  3487.                 G_pxyarray[1] = n_CsrYHaut;
  3488.                 G_pxyarray[2] = n_workXDroit;
  3489.                 G_pxyarray[3] = n_workYBas - line_h;
  3490.     
  3491.                 G_pxyarray[4] = n_workXGauche;            /* Coord destination */
  3492.                 G_pxyarray[5] = n_CsrYHaut + line_h;
  3493.                 G_pxyarray[6] = n_workXDroit;
  3494.                 G_pxyarray[7] = n_workYBas;
  3495.     
  3496.                 /* 
  3497.                  * D‚placement d'un bloc vers le bas sur l'‚cran logique: 
  3498.                  */
  3499.                 vro_cpyfm( G_ws_handle, S_ONLY, G_pxyarray,
  3500.                               &G_plogMFDB, &G_plogMFDB);
  3501.             
  3502.                 graf_mouse( M_ON, 0);                /* Affiche le ptr souris */
  3503.             }
  3504.             
  3505.             /*
  3506.              * Longueur de la ligne suivante
  3507.              * = longueur qu'on va devoir ‚craser
  3508.              */
  3509.             n_min_length = pTextLine_new -> next -> length; 
  3510.         }
  3511.     
  3512.         /*
  3513.          * Affiche la nouvelle ligne:
  3514.          * Prendre contr“le de l'‚cran!
  3515.          */
  3516.         redraw_textline(    pWiParams, pTextLine_new, 
  3517.                                 l_editLine, 0, 
  3518.                                 n_min_length * ( pTextDrawPar -> n_cell_w ) );
  3519.     }
  3520.  
  3521.  
  3522.     /*
  3523.      * Fin des op‚rations graphiques:
  3524.      * LibŠre l'‚cran:
  3525.      */
  3526.     end_WINDRAW();
  3527.     /*
  3528.      * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  3529.      */
  3530.  
  3531.  
  3532.     /*
  3533.      * Fixe nlle taille et position ascenseur: 
  3534.      */
  3535.     set_slider_h( pWiParams );            /* Fix taille slider vertical */
  3536.     set_slider_y( pWiParams );            /* Fix position slider vertical */
  3537.  
  3538.     /*
  3539.      * Signale … la fenˆtre que son contenu a ‚t‚ modifi‚:
  3540.      */
  3541.     Wnd_SetModified( pWiParams );
  3542. }
  3543.